import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            apiInstance.deleteV1UsersId(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteV1UsersId");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 

try {
    final result = await api_instance.deleteV1UsersId(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteV1UsersId: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            apiInstance.deleteV1UsersId(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteV1UsersId");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *id = id_example; //  (default to null)

[apiInstance deleteV1UsersIdWith:id
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var id = id_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteV1UsersId(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class deleteV1UsersIdExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var id = id_example;  // String |  (default to null)

            try {
                apiInstance.deleteV1UsersId(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.deleteV1UsersId: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $api_instance->deleteV1UsersId($id);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->deleteV1UsersId: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $id = id_example; # String | 

eval {
    $api_instance->deleteV1UsersId(id => $id);
};
if ($@) {
    warn "Exception when calling DefaultApi->deleteV1UsersId: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
id = id_example # String |  (default to null)

try:
    api_instance.delete_v1_users_id(id)
except ApiException as e:
    print("Exception when calling DefaultApi->deleteV1UsersId: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let id = id_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.deleteV1UsersId(id, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();

        try {
            get_v1_cards_pin_seeds___copy_200_response result = apiInstance.getV1CardsPinSeedsCopy();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getV1CardsPinSeedsCopy");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.getV1CardsPinSeedsCopy();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getV1CardsPinSeedsCopy: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();

        try {
            get_v1_cards_pin_seeds___copy_200_response result = apiInstance.getV1CardsPinSeedsCopy();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getV1CardsPinSeedsCopy");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];

// 
[apiInstance getV1CardsPinSeedsCopyWithCompletionHandler: 
              ^(get_v1_cards_pin_seeds___copy_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getV1CardsPinSeedsCopy(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getV1CardsPinSeedsCopyExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                // 
                get_v1_cards_pin_seeds___copy_200_response result = apiInstance.getV1CardsPinSeedsCopy();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getV1CardsPinSeedsCopy: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();

try {
    $result = $api_instance->getV1CardsPinSeedsCopy();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getV1CardsPinSeedsCopy: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

eval {
    my $result = $api_instance->getV1CardsPinSeedsCopy();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getV1CardsPinSeedsCopy: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()

try:
    # 
    api_response = api_instance.get_v1_cards_pin_seeds_copy()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getV1CardsPinSeedsCopy: %s\n" % e)

extern crate DefaultApi;

pub fn main() {

    let mut context = DefaultApi::Context::default();
    let result = client.getV1CardsPinSeedsCopy(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String supplierId = supplierId_example; // String | supplier identifier
        String source = source_example; // String | portal reference

        try {
            array[paymentTermsOutputArray_inner] result = apiInstance.getV1PaymentsMethods(supplierId, source);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getV1PaymentsMethods");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String supplierId = new String(); // String | supplier identifier
final String source = new String(); // String | portal reference

try {
    final result = await api_instance.getV1PaymentsMethods(supplierId, source);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getV1PaymentsMethods: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String supplierId = supplierId_example; // String | supplier identifier
        String source = source_example; // String | portal reference

        try {
            array[paymentTermsOutputArray_inner] result = apiInstance.getV1PaymentsMethods(supplierId, source);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getV1PaymentsMethods");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *supplierId = supplierId_example; // supplier identifier (optional) (default to null)
String *source = source_example; // portal reference (optional) (default to null)

[apiInstance getV1PaymentsMethodsWith:supplierId
    source:source
              completionHandler: ^(array[paymentTermsOutputArray_inner] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var opts = {
  'supplierId': supplierId_example, // {String} supplier identifier
  'source': source_example // {String} portal reference
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getV1PaymentsMethods(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getV1PaymentsMethodsExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var supplierId = supplierId_example;  // String | supplier identifier (optional)  (default to null)
            var source = source_example;  // String | portal reference (optional)  (default to null)

            try {
                array[paymentTermsOutputArray_inner] result = apiInstance.getV1PaymentsMethods(supplierId, source);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getV1PaymentsMethods: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$supplierId = supplierId_example; // String | supplier identifier
$source = source_example; // String | portal reference

try {
    $result = $api_instance->getV1PaymentsMethods($supplierId, $source);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getV1PaymentsMethods: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $supplierId = supplierId_example; # String | supplier identifier
my $source = source_example; # String | portal reference

eval {
    my $result = $api_instance->getV1PaymentsMethods(supplierId => $supplierId, source => $source);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getV1PaymentsMethods: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
supplierId = supplierId_example # String | supplier identifier (optional) (default to null)
source = source_example # String | portal reference (optional) (default to null)

try:
    api_response = api_instance.get_v1_payments_methods(supplierId=supplierId, source=source)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getV1PaymentsMethods: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let supplierId = supplierId_example; // String
    let source = source_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.getV1PaymentsMethods(supplierId, source, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        Integer id = 56; // Integer | 

        try {
            userOutput result = apiInstance.getV1UsersId(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getV1UsersId");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer id = new Integer(); // Integer | 

try {
    final result = await api_instance.getV1UsersId(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getV1UsersId: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer id = 56; // Integer | 

        try {
            userOutput result = apiInstance.getV1UsersId(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getV1UsersId");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
Integer *id = 56; //  (default to null)

// 
[apiInstance getV1UsersIdWith:id
              completionHandler: ^(userOutput output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var id = 56; // {Integer} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getV1UsersId(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getV1UsersIdExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var id = 56;  // Integer |  (default to null)

            try {
                // 
                userOutput result = apiInstance.getV1UsersId(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getV1UsersId: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$id = 56; // Integer | 

try {
    $result = $api_instance->getV1UsersId($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getV1UsersId: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $id = 56; # Integer | 

eval {
    my $result = $api_instance->getV1UsersId(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getV1UsersId: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
id = 56 # Integer |  (default to null)

try:
    # 
    api_response = api_instance.get_v1_users_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getV1UsersId: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let id = 56; // Integer

    let mut context = DefaultApi::Context::default();
    let result = client.getV1UsersId(id, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();

        try {
            apiInstance.post summary report();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#post summary report");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.post summary report();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->post summary report: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();

        try {
            apiInstance.post summary report();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#post summary report");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance post summary reportWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.post summary report(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class post summary reportExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                apiInstance.post summary report();
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.post summary report: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();

try {
    $api_instance->post summary report();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->post summary report: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

eval {
    $api_instance->post summary report();
};
if ($@) {
    warn "Exception when calling DefaultApi->post summary report: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()

try:
    api_instance.post_summary_report()
except ApiException as e:
    print("Exception when calling DefaultApi->post summary report: %s\n" % e)

extern crate DefaultApi;

pub fn main() {

    let mut context = DefaultApi::Context::default();
    let result = client.post summary report(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        PostV1CardsPinOnlineRequest postV1CardsPinOnlineRequest = ; // PostV1CardsPinOnlineRequest | 

        try {
            post_v1_cards_pin_online_200_response result = apiInstance.postV1CardsPinOnline(postV1CardsPinOnlineRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#postV1CardsPinOnline");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final PostV1CardsPinOnlineRequest postV1CardsPinOnlineRequest = new PostV1CardsPinOnlineRequest(); // PostV1CardsPinOnlineRequest | 

try {
    final result = await api_instance.postV1CardsPinOnline(postV1CardsPinOnlineRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->postV1CardsPinOnline: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        PostV1CardsPinOnlineRequest postV1CardsPinOnlineRequest = ; // PostV1CardsPinOnlineRequest | 

        try {
            post_v1_cards_pin_online_200_response result = apiInstance.postV1CardsPinOnline(postV1CardsPinOnlineRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#postV1CardsPinOnline");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
PostV1CardsPinOnlineRequest *postV1CardsPinOnlineRequest = ; //  (optional)

// 
[apiInstance postV1CardsPinOnlineWith:postV1CardsPinOnlineRequest
              completionHandler: ^(post_v1_cards_pin_online_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var opts = {
  'postV1CardsPinOnlineRequest':  // {PostV1CardsPinOnlineRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.postV1CardsPinOnline(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class postV1CardsPinOnlineExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var postV1CardsPinOnlineRequest = new PostV1CardsPinOnlineRequest(); // PostV1CardsPinOnlineRequest |  (optional) 

            try {
                // 
                post_v1_cards_pin_online_200_response result = apiInstance.postV1CardsPinOnline(postV1CardsPinOnlineRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.postV1CardsPinOnline: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$postV1CardsPinOnlineRequest = ; // PostV1CardsPinOnlineRequest | 

try {
    $result = $api_instance->postV1CardsPinOnline($postV1CardsPinOnlineRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->postV1CardsPinOnline: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $postV1CardsPinOnlineRequest = WWW::OPenAPIClient::Object::PostV1CardsPinOnlineRequest->new(); # PostV1CardsPinOnlineRequest | 

eval {
    my $result = $api_instance->postV1CardsPinOnline(postV1CardsPinOnlineRequest => $postV1CardsPinOnlineRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->postV1CardsPinOnline: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
postV1CardsPinOnlineRequest =  # PostV1CardsPinOnlineRequest |  (optional)

try:
    # 
    api_response = api_instance.post_v1_cards_pin_online(postV1CardsPinOnlineRequest=postV1CardsPinOnlineRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->postV1CardsPinOnline: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let postV1CardsPinOnlineRequest = ; // PostV1CardsPinOnlineRequest

    let mut context = DefaultApi::Context::default();
    let result = client.postV1CardsPinOnline(postV1CardsPinOnlineRequest, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        GetTransactionDetailByQrInput getTransactionDetailByQrInput = ; // GetTransactionDetailByQrInput | 

        try {
            array[supplyOutputArray_inner] result = apiInstance.postV1SuppliesSearchQr(getTransactionDetailByQrInput);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#postV1SuppliesSearchQr");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final GetTransactionDetailByQrInput getTransactionDetailByQrInput = new GetTransactionDetailByQrInput(); // GetTransactionDetailByQrInput | 

try {
    final result = await api_instance.postV1SuppliesSearchQr(getTransactionDetailByQrInput);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->postV1SuppliesSearchQr: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        GetTransactionDetailByQrInput getTransactionDetailByQrInput = ; // GetTransactionDetailByQrInput | 

        try {
            array[supplyOutputArray_inner] result = apiInstance.postV1SuppliesSearchQr(getTransactionDetailByQrInput);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#postV1SuppliesSearchQr");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
GetTransactionDetailByQrInput *getTransactionDetailByQrInput = ; //  (optional)

// 
[apiInstance postV1SuppliesSearchQrWith:getTransactionDetailByQrInput
              completionHandler: ^(array[supplyOutputArray_inner] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var opts = {
  'getTransactionDetailByQrInput':  // {GetTransactionDetailByQrInput} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.postV1SuppliesSearchQr(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class postV1SuppliesSearchQrExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var getTransactionDetailByQrInput = new GetTransactionDetailByQrInput(); // GetTransactionDetailByQrInput |  (optional) 

            try {
                // 
                array[supplyOutputArray_inner] result = apiInstance.postV1SuppliesSearchQr(getTransactionDetailByQrInput);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.postV1SuppliesSearchQr: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$getTransactionDetailByQrInput = ; // GetTransactionDetailByQrInput | 

try {
    $result = $api_instance->postV1SuppliesSearchQr($getTransactionDetailByQrInput);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->postV1SuppliesSearchQr: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $getTransactionDetailByQrInput = WWW::OPenAPIClient::Object::GetTransactionDetailByQrInput->new(); # GetTransactionDetailByQrInput | 

eval {
    my $result = $api_instance->postV1SuppliesSearchQr(getTransactionDetailByQrInput => $getTransactionDetailByQrInput);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->postV1SuppliesSearchQr: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
getTransactionDetailByQrInput =  # GetTransactionDetailByQrInput |  (optional)

try:
    # 
    api_response = api_instance.post_v1_supplies_search_qr(getTransactionDetailByQrInput=getTransactionDetailByQrInput)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->postV1SuppliesSearchQr: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let getTransactionDetailByQrInput = ; // GetTransactionDetailByQrInput

    let mut context = DefaultApi::Context::default();
    let result = client.postV1SuppliesSearchQr(getTransactionDetailByQrInput, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        UpsertMarginManagementConfiguration upsertMarginManagementConfiguration = ; // UpsertMarginManagementConfiguration | 

        try {
            apiInstance.postV1TanksMarginManagementConfiguration(upsertMarginManagementConfiguration);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#postV1TanksMarginManagementConfiguration");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UpsertMarginManagementConfiguration upsertMarginManagementConfiguration = new UpsertMarginManagementConfiguration(); // UpsertMarginManagementConfiguration | 

try {
    final result = await api_instance.postV1TanksMarginManagementConfiguration(upsertMarginManagementConfiguration);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->postV1TanksMarginManagementConfiguration: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        UpsertMarginManagementConfiguration upsertMarginManagementConfiguration = ; // UpsertMarginManagementConfiguration | 

        try {
            apiInstance.postV1TanksMarginManagementConfiguration(upsertMarginManagementConfiguration);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#postV1TanksMarginManagementConfiguration");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
UpsertMarginManagementConfiguration *upsertMarginManagementConfiguration = ; //  (optional)

// 
[apiInstance postV1TanksMarginManagementConfigurationWith:upsertMarginManagementConfiguration
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var opts = {
  'upsertMarginManagementConfiguration':  // {UpsertMarginManagementConfiguration} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.postV1TanksMarginManagementConfiguration(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class postV1TanksMarginManagementConfigurationExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var upsertMarginManagementConfiguration = new UpsertMarginManagementConfiguration(); // UpsertMarginManagementConfiguration |  (optional) 

            try {
                // 
                apiInstance.postV1TanksMarginManagementConfiguration(upsertMarginManagementConfiguration);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.postV1TanksMarginManagementConfiguration: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$upsertMarginManagementConfiguration = ; // UpsertMarginManagementConfiguration | 

try {
    $api_instance->postV1TanksMarginManagementConfiguration($upsertMarginManagementConfiguration);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->postV1TanksMarginManagementConfiguration: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $upsertMarginManagementConfiguration = WWW::OPenAPIClient::Object::UpsertMarginManagementConfiguration->new(); # UpsertMarginManagementConfiguration | 

eval {
    $api_instance->postV1TanksMarginManagementConfiguration(upsertMarginManagementConfiguration => $upsertMarginManagementConfiguration);
};
if ($@) {
    warn "Exception when calling DefaultApi->postV1TanksMarginManagementConfiguration: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
upsertMarginManagementConfiguration =  # UpsertMarginManagementConfiguration |  (optional)

try:
    # 
    api_instance.post_v1_tanks_margin_management_configuration(upsertMarginManagementConfiguration=upsertMarginManagementConfiguration)
except ApiException as e:
    print("Exception when calling DefaultApi->postV1TanksMarginManagementConfiguration: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let upsertMarginManagementConfiguration = ; // UpsertMarginManagementConfiguration

    let mut context = DefaultApi::Context::default();
    let result = client.postV1TanksMarginManagementConfiguration(upsertMarginManagementConfiguration, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        array[Object] requestBody = ; // array[Object] | 

        try {
            apiInstance.putV1PaymentsMethods(requestBody);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#putV1PaymentsMethods");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final array[Object] requestBody = new array[Object](); // array[Object] | 

try {
    final result = await api_instance.putV1PaymentsMethods(requestBody);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->putV1PaymentsMethods: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        array[Object] requestBody = ; // array[Object] | 

        try {
            apiInstance.putV1PaymentsMethods(requestBody);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#putV1PaymentsMethods");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
array[Object] *requestBody = ; //  (optional)

// 
[apiInstance putV1PaymentsMethodsWith:requestBody
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var opts = {
  'requestBody':  // {array[Object]} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.putV1PaymentsMethods(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class putV1PaymentsMethodsExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var requestBody = new array[Object](); // array[Object] |  (optional) 

            try {
                // 
                apiInstance.putV1PaymentsMethods(requestBody);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.putV1PaymentsMethods: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$requestBody = ; // array[Object] | 

try {
    $api_instance->putV1PaymentsMethods($requestBody);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->putV1PaymentsMethods: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $requestBody = [WWW::OPenAPIClient::Object::array[Object]->new()]; # array[Object] | 

eval {
    $api_instance->putV1PaymentsMethods(requestBody => $requestBody);
};
if ($@) {
    warn "Exception when calling DefaultApi->putV1PaymentsMethods: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
requestBody =  # array[Object] |  (optional)

try:
    # 
    api_instance.put_v1_payments_methods(requestBody=requestBody)
except ApiException as e:
    print("Exception when calling DefaultApi->putV1PaymentsMethods: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let requestBody = ; // array[Object]

    let mut context = DefaultApi::Context::default();
    let result = client.putV1PaymentsMethods(requestBody, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | invoice detail id
        UpdateInvoiceDetail updateInvoiceDetail = ; // UpdateInvoiceDetail | 

        try {
            apiInstance.updateInvoiceDetailId(id, updateInvoiceDetail);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateInvoiceDetailId");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | invoice detail id
final UpdateInvoiceDetail updateInvoiceDetail = new UpdateInvoiceDetail(); // UpdateInvoiceDetail | 

try {
    final result = await api_instance.updateInvoiceDetailId(id, updateInvoiceDetail);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateInvoiceDetailId: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | invoice detail id
        UpdateInvoiceDetail updateInvoiceDetail = ; // UpdateInvoiceDetail | 

        try {
            apiInstance.updateInvoiceDetailId(id, updateInvoiceDetail);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateInvoiceDetailId");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *id = id_example; // invoice detail id (default to null)
UpdateInvoiceDetail *updateInvoiceDetail = ; // 

// Update an invoice detail
[apiInstance updateInvoiceDetailIdWith:id
    updateInvoiceDetail:updateInvoiceDetail
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var id = id_example; // {String} invoice detail id
var updateInvoiceDetail = ; // {UpdateInvoiceDetail} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.updateInvoiceDetailId(id, updateInvoiceDetail, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class updateInvoiceDetailIdExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var id = id_example;  // String | invoice detail id (default to null)
            var updateInvoiceDetail = new UpdateInvoiceDetail(); // UpdateInvoiceDetail | 

            try {
                // Update an invoice detail
                apiInstance.updateInvoiceDetailId(id, updateInvoiceDetail);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.updateInvoiceDetailId: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$id = id_example; // String | invoice detail id
$updateInvoiceDetail = ; // UpdateInvoiceDetail | 

try {
    $api_instance->updateInvoiceDetailId($id, $updateInvoiceDetail);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->updateInvoiceDetailId: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $id = id_example; # String | invoice detail id
my $updateInvoiceDetail = WWW::OPenAPIClient::Object::UpdateInvoiceDetail->new(); # UpdateInvoiceDetail | 

eval {
    $api_instance->updateInvoiceDetailId(id => $id, updateInvoiceDetail => $updateInvoiceDetail);
};
if ($@) {
    warn "Exception when calling DefaultApi->updateInvoiceDetailId: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
id = id_example # String | invoice detail id (default to null)
updateInvoiceDetail =  # UpdateInvoiceDetail | 

try:
    # Update an invoice detail
    api_instance.update_invoice_detail_id(id, updateInvoiceDetail)
except ApiException as e:
    print("Exception when calling DefaultApi->updateInvoiceDetailId: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let id = id_example; // String
    let updateInvoiceDetail = ; // UpdateInvoiceDetail

    let mut context = DefaultApi::Context::default();
    let result = client.updateInvoiceDetailId(id, updateInvoiceDetail, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        PostSummaryReport postSummaryReport = ; // PostSummaryReport | 

        try {
            apiInstance.utfPost(postSummaryReport);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#utfPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final PostSummaryReport postSummaryReport = new PostSummaryReport(); // PostSummaryReport | 

try {
    final result = await api_instance.utfPost(postSummaryReport);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->utfPost: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        PostSummaryReport postSummaryReport = ; // PostSummaryReport | 

        try {
            apiInstance.utfPost(postSummaryReport);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#utfPost");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
PostSummaryReport *postSummaryReport = ; //  (optional)

// 
[apiInstance utfPostWith:postSummaryReport
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var opts = {
  'postSummaryReport':  // {PostSummaryReport} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.utfPost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class utfPostExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var postSummaryReport = new PostSummaryReport(); // PostSummaryReport |  (optional) 

            try {
                // 
                apiInstance.utfPost(postSummaryReport);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.utfPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$postSummaryReport = ; // PostSummaryReport | 

try {
    $api_instance->utfPost($postSummaryReport);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->utfPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $postSummaryReport = WWW::OPenAPIClient::Object::PostSummaryReport->new(); # PostSummaryReport | 

eval {
    $api_instance->utfPost(postSummaryReport => $postSummaryReport);
};
if ($@) {
    warn "Exception when calling DefaultApi->utfPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
postSummaryReport =  # PostSummaryReport |  (optional)

try:
    # 
    api_instance.utf_post(postSummaryReport=postSummaryReport)
except ApiException as e:
    print("Exception when calling DefaultApi->utfPost: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let postSummaryReport = ; // PostSummaryReport

    let mut context = DefaultApi::Context::default();
    let result = client.utfPost(postSummaryReport, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            apiInstance.v1AppliedPricesIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1AppliedPricesIdDelete");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 

try {
    final result = await api_instance.v1AppliedPricesIdDelete(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1AppliedPricesIdDelete: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            apiInstance.v1AppliedPricesIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1AppliedPricesIdDelete");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *id = id_example; //  (default to null)

[apiInstance v1AppliedPricesIdDeleteWith:id
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var id = id_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1AppliedPricesIdDelete(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1AppliedPricesIdDeleteExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var id = id_example;  // String |  (default to null)

            try {
                apiInstance.v1AppliedPricesIdDelete(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1AppliedPricesIdDelete: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $api_instance->v1AppliedPricesIdDelete($id);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1AppliedPricesIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $id = id_example; # String | 

eval {
    $api_instance->v1AppliedPricesIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1AppliedPricesIdDelete: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
id = id_example # String |  (default to null)

try:
    api_instance.v1_applied_prices_id_delete(id)
except ApiException as e:
    print("Exception when calling DefaultApi->v1AppliedPricesIdDelete: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let id = id_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.v1AppliedPricesIdDelete(id, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            appliedPriceOutput result = apiInstance.v1AppliedPricesIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1AppliedPricesIdGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 

try {
    final result = await api_instance.v1AppliedPricesIdGet(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1AppliedPricesIdGet: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            appliedPriceOutput result = apiInstance.v1AppliedPricesIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1AppliedPricesIdGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *id = id_example; //  (default to null)

[apiInstance v1AppliedPricesIdGetWith:id
              completionHandler: ^(appliedPriceOutput output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var id = id_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.v1AppliedPricesIdGet(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1AppliedPricesIdGetExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var id = id_example;  // String |  (default to null)

            try {
                appliedPriceOutput result = apiInstance.v1AppliedPricesIdGet(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1AppliedPricesIdGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $result = $api_instance->v1AppliedPricesIdGet($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1AppliedPricesIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $id = id_example; # String | 

eval {
    my $result = $api_instance->v1AppliedPricesIdGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1AppliedPricesIdGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
id = id_example # String |  (default to null)

try:
    api_response = api_instance.v1_applied_prices_id_get(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->v1AppliedPricesIdGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let id = id_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.v1AppliedPricesIdGet(id, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        AppliedPriceInput appliedPriceInput = ; // AppliedPriceInput | 

        try {
            apiInstance.v1AppliedPricesIdPut(id, appliedPriceInput);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1AppliedPricesIdPut");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 
final AppliedPriceInput appliedPriceInput = new AppliedPriceInput(); // AppliedPriceInput | 

try {
    final result = await api_instance.v1AppliedPricesIdPut(id, appliedPriceInput);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1AppliedPricesIdPut: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        AppliedPriceInput appliedPriceInput = ; // AppliedPriceInput | 

        try {
            apiInstance.v1AppliedPricesIdPut(id, appliedPriceInput);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1AppliedPricesIdPut");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *id = id_example; //  (default to null)
AppliedPriceInput *appliedPriceInput = ; // 

[apiInstance v1AppliedPricesIdPutWith:id
    appliedPriceInput:appliedPriceInput
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var id = id_example; // {String} 
var appliedPriceInput = ; // {AppliedPriceInput} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1AppliedPricesIdPut(id, appliedPriceInput, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1AppliedPricesIdPutExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var id = id_example;  // String |  (default to null)
            var appliedPriceInput = new AppliedPriceInput(); // AppliedPriceInput | 

            try {
                apiInstance.v1AppliedPricesIdPut(id, appliedPriceInput);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1AppliedPricesIdPut: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$id = id_example; // String | 
$appliedPriceInput = ; // AppliedPriceInput | 

try {
    $api_instance->v1AppliedPricesIdPut($id, $appliedPriceInput);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1AppliedPricesIdPut: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $id = id_example; # String | 
my $appliedPriceInput = WWW::OPenAPIClient::Object::AppliedPriceInput->new(); # AppliedPriceInput | 

eval {
    $api_instance->v1AppliedPricesIdPut(id => $id, appliedPriceInput => $appliedPriceInput);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1AppliedPricesIdPut: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
id = id_example # String |  (default to null)
appliedPriceInput =  # AppliedPriceInput | 

try:
    api_instance.v1_applied_prices_id_put(id, appliedPriceInput)
except ApiException as e:
    print("Exception when calling DefaultApi->v1AppliedPricesIdPut: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let id = id_example; // String
    let appliedPriceInput = ; // AppliedPriceInput

    let mut context = DefaultApi::Context::default();
    let result = client.v1AppliedPricesIdPut(id, appliedPriceInput, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        AppliedPriceInput appliedPriceInput = ; // AppliedPriceInput | 

        try {
            apiInstance.v1AppliedPricesPost(appliedPriceInput);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1AppliedPricesPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final AppliedPriceInput appliedPriceInput = new AppliedPriceInput(); // AppliedPriceInput | 

try {
    final result = await api_instance.v1AppliedPricesPost(appliedPriceInput);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1AppliedPricesPost: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        AppliedPriceInput appliedPriceInput = ; // AppliedPriceInput | 

        try {
            apiInstance.v1AppliedPricesPost(appliedPriceInput);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1AppliedPricesPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
AppliedPriceInput *appliedPriceInput = ; // 

[apiInstance v1AppliedPricesPostWith:appliedPriceInput
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var appliedPriceInput = ; // {AppliedPriceInput} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1AppliedPricesPost(appliedPriceInput, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1AppliedPricesPostExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var appliedPriceInput = new AppliedPriceInput(); // AppliedPriceInput | 

            try {
                apiInstance.v1AppliedPricesPost(appliedPriceInput);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1AppliedPricesPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$appliedPriceInput = ; // AppliedPriceInput | 

try {
    $api_instance->v1AppliedPricesPost($appliedPriceInput);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1AppliedPricesPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $appliedPriceInput = WWW::OPenAPIClient::Object::AppliedPriceInput->new(); # AppliedPriceInput | 

eval {
    $api_instance->v1AppliedPricesPost(appliedPriceInput => $appliedPriceInput);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1AppliedPricesPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
appliedPriceInput =  # AppliedPriceInput | 

try:
    api_instance.v1_applied_prices_post(appliedPriceInput)
except ApiException as e:
    print("Exception when calling DefaultApi->v1AppliedPricesPost: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let appliedPriceInput = ; // AppliedPriceInput

    let mut context = DefaultApi::Context::default();
    let result = client.v1AppliedPricesPost(appliedPriceInput, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            apiInstance.v1ArticlesIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1ArticlesIdDelete");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 

try {
    final result = await api_instance.v1ArticlesIdDelete(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1ArticlesIdDelete: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            apiInstance.v1ArticlesIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1ArticlesIdDelete");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *id = id_example; //  (default to null)

[apiInstance v1ArticlesIdDeleteWith:id
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var id = id_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1ArticlesIdDelete(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1ArticlesIdDeleteExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var id = id_example;  // String |  (default to null)

            try {
                apiInstance.v1ArticlesIdDelete(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1ArticlesIdDelete: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $api_instance->v1ArticlesIdDelete($id);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1ArticlesIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $id = id_example; # String | 

eval {
    $api_instance->v1ArticlesIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1ArticlesIdDelete: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
id = id_example # String |  (default to null)

try:
    api_instance.v1_articles_id_delete(id)
except ApiException as e:
    print("Exception when calling DefaultApi->v1ArticlesIdDelete: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let id = id_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.v1ArticlesIdDelete(id, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            articleOutput result = apiInstance.v1ArticlesIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1ArticlesIdGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 

try {
    final result = await api_instance.v1ArticlesIdGet(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1ArticlesIdGet: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            articleOutput result = apiInstance.v1ArticlesIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1ArticlesIdGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *id = id_example; //  (default to null)

[apiInstance v1ArticlesIdGetWith:id
              completionHandler: ^(articleOutput output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var id = id_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.v1ArticlesIdGet(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1ArticlesIdGetExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var id = id_example;  // String |  (default to null)

            try {
                articleOutput result = apiInstance.v1ArticlesIdGet(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1ArticlesIdGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $result = $api_instance->v1ArticlesIdGet($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1ArticlesIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $id = id_example; # String | 

eval {
    my $result = $api_instance->v1ArticlesIdGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1ArticlesIdGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
id = id_example # String |  (default to null)

try:
    api_response = api_instance.v1_articles_id_get(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->v1ArticlesIdGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let id = id_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.v1ArticlesIdGet(id, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        ArticleInput articleInput = ; // ArticleInput | 

        try {
            apiInstance.v1ArticlesIdPut(id, articleInput);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1ArticlesIdPut");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 
final ArticleInput articleInput = new ArticleInput(); // ArticleInput | 

try {
    final result = await api_instance.v1ArticlesIdPut(id, articleInput);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1ArticlesIdPut: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        ArticleInput articleInput = ; // ArticleInput | 

        try {
            apiInstance.v1ArticlesIdPut(id, articleInput);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1ArticlesIdPut");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *id = id_example; //  (default to null)
ArticleInput *articleInput = ; // 

[apiInstance v1ArticlesIdPutWith:id
    articleInput:articleInput
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var id = id_example; // {String} 
var articleInput = ; // {ArticleInput} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1ArticlesIdPut(id, articleInput, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1ArticlesIdPutExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var id = id_example;  // String |  (default to null)
            var articleInput = new ArticleInput(); // ArticleInput | 

            try {
                apiInstance.v1ArticlesIdPut(id, articleInput);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1ArticlesIdPut: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$id = id_example; // String | 
$articleInput = ; // ArticleInput | 

try {
    $api_instance->v1ArticlesIdPut($id, $articleInput);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1ArticlesIdPut: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $id = id_example; # String | 
my $articleInput = WWW::OPenAPIClient::Object::ArticleInput->new(); # ArticleInput | 

eval {
    $api_instance->v1ArticlesIdPut(id => $id, articleInput => $articleInput);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1ArticlesIdPut: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
id = id_example # String |  (default to null)
articleInput =  # ArticleInput | 

try:
    api_instance.v1_articles_id_put(id, articleInput)
except ApiException as e:
    print("Exception when calling DefaultApi->v1ArticlesIdPut: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let id = id_example; // String
    let articleInput = ; // ArticleInput

    let mut context = DefaultApi::Context::default();
    let result = client.v1ArticlesIdPut(id, articleInput, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        ArticleInput articleInput = ; // ArticleInput | 

        try {
            apiInstance.v1ArticlesPost(articleInput);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1ArticlesPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ArticleInput articleInput = new ArticleInput(); // ArticleInput | 

try {
    final result = await api_instance.v1ArticlesPost(articleInput);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1ArticlesPost: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        ArticleInput articleInput = ; // ArticleInput | 

        try {
            apiInstance.v1ArticlesPost(articleInput);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1ArticlesPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
ArticleInput *articleInput = ; // 

[apiInstance v1ArticlesPostWith:articleInput
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var articleInput = ; // {ArticleInput} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1ArticlesPost(articleInput, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1ArticlesPostExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var articleInput = new ArticleInput(); // ArticleInput | 

            try {
                apiInstance.v1ArticlesPost(articleInput);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1ArticlesPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$articleInput = ; // ArticleInput | 

try {
    $api_instance->v1ArticlesPost($articleInput);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1ArticlesPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $articleInput = WWW::OPenAPIClient::Object::ArticleInput->new(); # ArticleInput | 

eval {
    $api_instance->v1ArticlesPost(articleInput => $articleInput);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1ArticlesPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
articleInput =  # ArticleInput | 

try:
    api_instance.v1_articles_post(articleInput)
except ApiException as e:
    print("Exception when calling DefaultApi->v1ArticlesPost: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let articleInput = ; // ArticleInput

    let mut context = DefaultApi::Context::default();
    let result = client.v1ArticlesPost(articleInput, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String categoryId = categoryId_example; // String | 
        String customerId = customerId_example; // String | 
        String fuelStationId = fuelStationId_example; // String | 
        String supplierId = supplierId_example; // String | 
        String cardId = cardId_example; // String | 
        String vehicleId = vehicleId_example; // String | 

        try {
            array[articleOutputArray_inner] result = apiInstance.v1ArticlesSearchGet(categoryId, customerId, fuelStationId, supplierId, cardId, vehicleId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1ArticlesSearchGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String categoryId = new String(); // String | 
final String customerId = new String(); // String | 
final String fuelStationId = new String(); // String | 
final String supplierId = new String(); // String | 
final String cardId = new String(); // String | 
final String vehicleId = new String(); // String | 

try {
    final result = await api_instance.v1ArticlesSearchGet(categoryId, customerId, fuelStationId, supplierId, cardId, vehicleId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1ArticlesSearchGet: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String categoryId = categoryId_example; // String | 
        String customerId = customerId_example; // String | 
        String fuelStationId = fuelStationId_example; // String | 
        String supplierId = supplierId_example; // String | 
        String cardId = cardId_example; // String | 
        String vehicleId = vehicleId_example; // String | 

        try {
            array[articleOutputArray_inner] result = apiInstance.v1ArticlesSearchGet(categoryId, customerId, fuelStationId, supplierId, cardId, vehicleId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1ArticlesSearchGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *categoryId = categoryId_example; //  (optional) (default to null)
String *customerId = customerId_example; //  (optional) (default to null)
String *fuelStationId = fuelStationId_example; //  (optional) (default to null)
String *supplierId = supplierId_example; //  (optional) (default to null)
String *cardId = cardId_example; //  (optional) (default to null)
String *vehicleId = vehicleId_example; //  (optional) (default to null)

[apiInstance v1ArticlesSearchGetWith:categoryId
    customerId:customerId
    fuelStationId:fuelStationId
    supplierId:supplierId
    cardId:cardId
    vehicleId:vehicleId
              completionHandler: ^(array[articleOutputArray_inner] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var opts = {
  'categoryId': categoryId_example, // {String} 
  'customerId': customerId_example, // {String} 
  'fuelStationId': fuelStationId_example, // {String} 
  'supplierId': supplierId_example, // {String} 
  'cardId': cardId_example, // {String} 
  'vehicleId': vehicleId_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.v1ArticlesSearchGet(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1ArticlesSearchGetExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var categoryId = categoryId_example;  // String |  (optional)  (default to null)
            var customerId = customerId_example;  // String |  (optional)  (default to null)
            var fuelStationId = fuelStationId_example;  // String |  (optional)  (default to null)
            var supplierId = supplierId_example;  // String |  (optional)  (default to null)
            var cardId = cardId_example;  // String |  (optional)  (default to null)
            var vehicleId = vehicleId_example;  // String |  (optional)  (default to null)

            try {
                array[articleOutputArray_inner] result = apiInstance.v1ArticlesSearchGet(categoryId, customerId, fuelStationId, supplierId, cardId, vehicleId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1ArticlesSearchGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$categoryId = categoryId_example; // String | 
$customerId = customerId_example; // String | 
$fuelStationId = fuelStationId_example; // String | 
$supplierId = supplierId_example; // String | 
$cardId = cardId_example; // String | 
$vehicleId = vehicleId_example; // String | 

try {
    $result = $api_instance->v1ArticlesSearchGet($categoryId, $customerId, $fuelStationId, $supplierId, $cardId, $vehicleId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1ArticlesSearchGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $categoryId = categoryId_example; # String | 
my $customerId = customerId_example; # String | 
my $fuelStationId = fuelStationId_example; # String | 
my $supplierId = supplierId_example; # String | 
my $cardId = cardId_example; # String | 
my $vehicleId = vehicleId_example; # String | 

eval {
    my $result = $api_instance->v1ArticlesSearchGet(categoryId => $categoryId, customerId => $customerId, fuelStationId => $fuelStationId, supplierId => $supplierId, cardId => $cardId, vehicleId => $vehicleId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1ArticlesSearchGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
categoryId = categoryId_example # String |  (optional) (default to null)
customerId = customerId_example # String |  (optional) (default to null)
fuelStationId = fuelStationId_example # String |  (optional) (default to null)
supplierId = supplierId_example # String |  (optional) (default to null)
cardId = cardId_example # String |  (optional) (default to null)
vehicleId = vehicleId_example # String |  (optional) (default to null)

try:
    api_response = api_instance.v1_articles_search_get(categoryId=categoryId, customerId=customerId, fuelStationId=fuelStationId, supplierId=supplierId, cardId=cardId, vehicleId=vehicleId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->v1ArticlesSearchGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let categoryId = categoryId_example; // String
    let customerId = customerId_example; // String
    let fuelStationId = fuelStationId_example; // String
    let supplierId = supplierId_example; // String
    let cardId = cardId_example; // String
    let vehicleId = vehicleId_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.v1ArticlesSearchGet(categoryId, customerId, fuelStationId, supplierId, cardId, vehicleId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            apiInstance.v1CardsIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CardsIdDelete");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 

try {
    final result = await api_instance.v1CardsIdDelete(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1CardsIdDelete: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            apiInstance.v1CardsIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CardsIdDelete");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *id = id_example; //  (default to null)

[apiInstance v1CardsIdDeleteWith:id
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var id = id_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1CardsIdDelete(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1CardsIdDeleteExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var id = id_example;  // String |  (default to null)

            try {
                apiInstance.v1CardsIdDelete(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1CardsIdDelete: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $api_instance->v1CardsIdDelete($id);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1CardsIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $id = id_example; # String | 

eval {
    $api_instance->v1CardsIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1CardsIdDelete: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
id = id_example # String |  (default to null)

try:
    api_instance.v1_cards_id_delete(id)
except ApiException as e:
    print("Exception when calling DefaultApi->v1CardsIdDelete: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let id = id_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.v1CardsIdDelete(id, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            cardOutput result = apiInstance.v1CardsIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CardsIdGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 

try {
    final result = await api_instance.v1CardsIdGet(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1CardsIdGet: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            cardOutput result = apiInstance.v1CardsIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CardsIdGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *id = id_example; //  (default to null)

[apiInstance v1CardsIdGetWith:id
              completionHandler: ^(cardOutput output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var id = id_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.v1CardsIdGet(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1CardsIdGetExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var id = id_example;  // String |  (default to null)

            try {
                cardOutput result = apiInstance.v1CardsIdGet(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1CardsIdGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $result = $api_instance->v1CardsIdGet($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1CardsIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $id = id_example; # String | 

eval {
    my $result = $api_instance->v1CardsIdGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1CardsIdGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
id = id_example # String |  (default to null)

try:
    api_response = api_instance.v1_cards_id_get(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->v1CardsIdGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let id = id_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.v1CardsIdGet(id, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        CardInput cardInput = ; // CardInput | 

        try {
            apiInstance.v1CardsIdPut(id, cardInput);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CardsIdPut");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 
final CardInput cardInput = new CardInput(); // CardInput | 

try {
    final result = await api_instance.v1CardsIdPut(id, cardInput);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1CardsIdPut: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        CardInput cardInput = ; // CardInput | 

        try {
            apiInstance.v1CardsIdPut(id, cardInput);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CardsIdPut");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *id = id_example; //  (default to null)
CardInput *cardInput = ; // 

[apiInstance v1CardsIdPutWith:id
    cardInput:cardInput
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var id = id_example; // {String} 
var cardInput = ; // {CardInput} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1CardsIdPut(id, cardInput, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1CardsIdPutExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var id = id_example;  // String |  (default to null)
            var cardInput = new CardInput(); // CardInput | 

            try {
                apiInstance.v1CardsIdPut(id, cardInput);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1CardsIdPut: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$id = id_example; // String | 
$cardInput = ; // CardInput | 

try {
    $api_instance->v1CardsIdPut($id, $cardInput);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1CardsIdPut: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $id = id_example; # String | 
my $cardInput = WWW::OPenAPIClient::Object::CardInput->new(); # CardInput | 

eval {
    $api_instance->v1CardsIdPut(id => $id, cardInput => $cardInput);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1CardsIdPut: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
id = id_example # String |  (default to null)
cardInput =  # CardInput | 

try:
    api_instance.v1_cards_id_put(id, cardInput)
except ApiException as e:
    print("Exception when calling DefaultApi->v1CardsIdPut: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let id = id_example; // String
    let cardInput = ; // CardInput

    let mut context = DefaultApi::Context::default();
    let result = client.v1CardsIdPut(id, cardInput, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            array[cardUnlockHistoryOutput_inner] result = apiInstance.v1CardsIdUnlockHistoryGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CardsIdUnlockHistoryGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 

try {
    final result = await api_instance.v1CardsIdUnlockHistoryGet(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1CardsIdUnlockHistoryGet: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            array[cardUnlockHistoryOutput_inner] result = apiInstance.v1CardsIdUnlockHistoryGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CardsIdUnlockHistoryGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *id = id_example; //  (default to null)

[apiInstance v1CardsIdUnlockHistoryGetWith:id
              completionHandler: ^(array[cardUnlockHistoryOutput_inner] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var id = id_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.v1CardsIdUnlockHistoryGet(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1CardsIdUnlockHistoryGetExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var id = id_example;  // String |  (default to null)

            try {
                array[cardUnlockHistoryOutput_inner] result = apiInstance.v1CardsIdUnlockHistoryGet(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1CardsIdUnlockHistoryGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $result = $api_instance->v1CardsIdUnlockHistoryGet($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1CardsIdUnlockHistoryGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $id = id_example; # String | 

eval {
    my $result = $api_instance->v1CardsIdUnlockHistoryGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1CardsIdUnlockHistoryGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
id = id_example # String |  (default to null)

try:
    api_response = api_instance.v1_cards_id_unlock_history_get(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->v1CardsIdUnlockHistoryGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let id = id_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.v1CardsIdUnlockHistoryGet(id, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        CardLockInput cardLockInput = ; // CardLockInput | 

        try {
            apiInstance.v1CardsLockPost(cardLockInput);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CardsLockPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CardLockInput cardLockInput = new CardLockInput(); // CardLockInput | 

try {
    final result = await api_instance.v1CardsLockPost(cardLockInput);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1CardsLockPost: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        CardLockInput cardLockInput = ; // CardLockInput | 

        try {
            apiInstance.v1CardsLockPost(cardLockInput);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CardsLockPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
CardLockInput *cardLockInput = ; // 

[apiInstance v1CardsLockPostWith:cardLockInput
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var cardLockInput = ; // {CardLockInput} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1CardsLockPost(cardLockInput, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1CardsLockPostExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var cardLockInput = new CardLockInput(); // CardLockInput | 

            try {
                apiInstance.v1CardsLockPost(cardLockInput);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1CardsLockPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$cardLockInput = ; // CardLockInput | 

try {
    $api_instance->v1CardsLockPost($cardLockInput);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1CardsLockPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $cardLockInput = WWW::OPenAPIClient::Object::CardLockInput->new(); # CardLockInput | 

eval {
    $api_instance->v1CardsLockPost(cardLockInput => $cardLockInput);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1CardsLockPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
cardLockInput =  # CardLockInput | 

try:
    api_instance.v1_cards_lock_post(cardLockInput)
except ApiException as e:
    print("Exception when calling DefaultApi->v1CardsLockPost: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let cardLockInput = ; // CardLockInput

    let mut context = DefaultApi::Context::default();
    let result = client.v1CardsLockPost(cardLockInput, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        V1CardsPinSeedsPostRequest v1CardsPinSeedsPostRequest = ; // V1CardsPinSeedsPostRequest | 

        try {
            _v1_cards_pin_seeds_post_200_response result = apiInstance.v1CardsPinSeedsPost(v1CardsPinSeedsPostRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CardsPinSeedsPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final V1CardsPinSeedsPostRequest v1CardsPinSeedsPostRequest = new V1CardsPinSeedsPostRequest(); // V1CardsPinSeedsPostRequest | 

try {
    final result = await api_instance.v1CardsPinSeedsPost(v1CardsPinSeedsPostRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1CardsPinSeedsPost: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        V1CardsPinSeedsPostRequest v1CardsPinSeedsPostRequest = ; // V1CardsPinSeedsPostRequest | 

        try {
            _v1_cards_pin_seeds_post_200_response result = apiInstance.v1CardsPinSeedsPost(v1CardsPinSeedsPostRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CardsPinSeedsPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
V1CardsPinSeedsPostRequest *v1CardsPinSeedsPostRequest = ; // 

[apiInstance v1CardsPinSeedsPostWith:v1CardsPinSeedsPostRequest
              completionHandler: ^(_v1_cards_pin_seeds_post_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var v1CardsPinSeedsPostRequest = ; // {V1CardsPinSeedsPostRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.v1CardsPinSeedsPost(v1CardsPinSeedsPostRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1CardsPinSeedsPostExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var v1CardsPinSeedsPostRequest = new V1CardsPinSeedsPostRequest(); // V1CardsPinSeedsPostRequest | 

            try {
                _v1_cards_pin_seeds_post_200_response result = apiInstance.v1CardsPinSeedsPost(v1CardsPinSeedsPostRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1CardsPinSeedsPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$v1CardsPinSeedsPostRequest = ; // V1CardsPinSeedsPostRequest | 

try {
    $result = $api_instance->v1CardsPinSeedsPost($v1CardsPinSeedsPostRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1CardsPinSeedsPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $v1CardsPinSeedsPostRequest = WWW::OPenAPIClient::Object::V1CardsPinSeedsPostRequest->new(); # V1CardsPinSeedsPostRequest | 

eval {
    my $result = $api_instance->v1CardsPinSeedsPost(v1CardsPinSeedsPostRequest => $v1CardsPinSeedsPostRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1CardsPinSeedsPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
v1CardsPinSeedsPostRequest =  # V1CardsPinSeedsPostRequest | 

try:
    api_response = api_instance.v1_cards_pin_seeds_post(v1CardsPinSeedsPostRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->v1CardsPinSeedsPost: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let v1CardsPinSeedsPostRequest = ; // V1CardsPinSeedsPostRequest

    let mut context = DefaultApi::Context::default();
    let result = client.v1CardsPinSeedsPost(v1CardsPinSeedsPostRequest, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        array[cardInputArray_inner] cardInputArrayInner = ; // array[cardInputArray_inner] | 

        try {
            apiInstance.v1CardsPost(cardInputArrayInner);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CardsPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final array[cardInputArray_inner] cardInputArrayInner = new array[cardInputArray_inner](); // array[cardInputArray_inner] | 

try {
    final result = await api_instance.v1CardsPost(cardInputArrayInner);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1CardsPost: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        array[cardInputArray_inner] cardInputArrayInner = ; // array[cardInputArray_inner] | 

        try {
            apiInstance.v1CardsPost(cardInputArrayInner);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CardsPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
array[cardInputArray_inner] *cardInputArrayInner = ; // 

[apiInstance v1CardsPostWith:cardInputArrayInner
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var cardInputArrayInner = ; // {array[cardInputArray_inner]} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1CardsPost(cardInputArrayInner, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1CardsPostExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var cardInputArrayInner = new array[cardInputArray_inner](); // array[cardInputArray_inner] | 

            try {
                apiInstance.v1CardsPost(cardInputArrayInner);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1CardsPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$cardInputArrayInner = ; // array[cardInputArray_inner] | 

try {
    $api_instance->v1CardsPost($cardInputArrayInner);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1CardsPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $cardInputArrayInner = [WWW::OPenAPIClient::Object::array[cardInputArray_inner]->new()]; # array[cardInputArray_inner] | 

eval {
    $api_instance->v1CardsPost(cardInputArrayInner => $cardInputArrayInner);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1CardsPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
cardInputArrayInner =  # array[cardInputArray_inner] | 

try:
    api_instance.v1_cards_post(cardInputArrayInner)
except ApiException as e:
    print("Exception when calling DefaultApi->v1CardsPost: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let cardInputArrayInner = ; // array[cardInputArray_inner]

    let mut context = DefaultApi::Context::default();
    let result = client.v1CardsPost(cardInputArrayInner, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        CardRangeInput cardRangeInput = ; // CardRangeInput | 

        try {
            apiInstance.v1CardsRangePost(cardRangeInput);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CardsRangePost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CardRangeInput cardRangeInput = new CardRangeInput(); // CardRangeInput | 

try {
    final result = await api_instance.v1CardsRangePost(cardRangeInput);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1CardsRangePost: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        CardRangeInput cardRangeInput = ; // CardRangeInput | 

        try {
            apiInstance.v1CardsRangePost(cardRangeInput);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CardsRangePost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
CardRangeInput *cardRangeInput = ; // 

[apiInstance v1CardsRangePostWith:cardRangeInput
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var cardRangeInput = ; // {CardRangeInput} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1CardsRangePost(cardRangeInput, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1CardsRangePostExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var cardRangeInput = new CardRangeInput(); // CardRangeInput | 

            try {
                apiInstance.v1CardsRangePost(cardRangeInput);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1CardsRangePost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$cardRangeInput = ; // CardRangeInput | 

try {
    $api_instance->v1CardsRangePost($cardRangeInput);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1CardsRangePost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $cardRangeInput = WWW::OPenAPIClient::Object::CardRangeInput->new(); # CardRangeInput | 

eval {
    $api_instance->v1CardsRangePost(cardRangeInput => $cardRangeInput);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1CardsRangePost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
cardRangeInput =  # CardRangeInput | 

try:
    api_instance.v1_cards_range_post(cardRangeInput)
except ApiException as e:
    print("Exception when calling DefaultApi->v1CardsRangePost: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let cardRangeInput = ; // CardRangeInput

    let mut context = DefaultApi::Context::default();
    let result = client.v1CardsRangePost(cardRangeInput, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        CardUnLockInput cardUnLockInput = ; // CardUnLockInput | 

        try {
            apiInstance.v1CardsUnlockPost(cardUnLockInput);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CardsUnlockPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CardUnLockInput cardUnLockInput = new CardUnLockInput(); // CardUnLockInput | 

try {
    final result = await api_instance.v1CardsUnlockPost(cardUnLockInput);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1CardsUnlockPost: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        CardUnLockInput cardUnLockInput = ; // CardUnLockInput | 

        try {
            apiInstance.v1CardsUnlockPost(cardUnLockInput);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CardsUnlockPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
CardUnLockInput *cardUnLockInput = ; // 

[apiInstance v1CardsUnlockPostWith:cardUnLockInput
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var cardUnLockInput = ; // {CardUnLockInput} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1CardsUnlockPost(cardUnLockInput, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1CardsUnlockPostExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var cardUnLockInput = new CardUnLockInput(); // CardUnLockInput | 

            try {
                apiInstance.v1CardsUnlockPost(cardUnLockInput);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1CardsUnlockPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$cardUnLockInput = ; // CardUnLockInput | 

try {
    $api_instance->v1CardsUnlockPost($cardUnLockInput);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1CardsUnlockPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $cardUnLockInput = WWW::OPenAPIClient::Object::CardUnLockInput->new(); # CardUnLockInput | 

eval {
    $api_instance->v1CardsUnlockPost(cardUnLockInput => $cardUnLockInput);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1CardsUnlockPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
cardUnLockInput =  # CardUnLockInput | 

try:
    api_instance.v1_cards_unlock_post(cardUnLockInput)
except ApiException as e:
    print("Exception when calling DefaultApi->v1CardsUnlockPost: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let cardUnLockInput = ; // CardUnLockInput

    let mut context = DefaultApi::Context::default();
    let result = client.v1CardsUnlockPost(cardUnLockInput, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            array[articleOutputArray_inner] result = apiInstance.v1CategoriesIdArticlesGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CategoriesIdArticlesGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 

try {
    final result = await api_instance.v1CategoriesIdArticlesGet(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1CategoriesIdArticlesGet: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            array[articleOutputArray_inner] result = apiInstance.v1CategoriesIdArticlesGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CategoriesIdArticlesGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *id = id_example; //  (default to null)

[apiInstance v1CategoriesIdArticlesGetWith:id
              completionHandler: ^(array[articleOutputArray_inner] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var id = id_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.v1CategoriesIdArticlesGet(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1CategoriesIdArticlesGetExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var id = id_example;  // String |  (default to null)

            try {
                array[articleOutputArray_inner] result = apiInstance.v1CategoriesIdArticlesGet(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1CategoriesIdArticlesGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $result = $api_instance->v1CategoriesIdArticlesGet($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1CategoriesIdArticlesGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $id = id_example; # String | 

eval {
    my $result = $api_instance->v1CategoriesIdArticlesGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1CategoriesIdArticlesGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
id = id_example # String |  (default to null)

try:
    api_response = api_instance.v1_categories_id_articles_get(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->v1CategoriesIdArticlesGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let id = id_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.v1CategoriesIdArticlesGet(id, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            apiInstance.v1CategoriesIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CategoriesIdDelete");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 

try {
    final result = await api_instance.v1CategoriesIdDelete(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1CategoriesIdDelete: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            apiInstance.v1CategoriesIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CategoriesIdDelete");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *id = id_example; //  (default to null)

[apiInstance v1CategoriesIdDeleteWith:id
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var id = id_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1CategoriesIdDelete(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1CategoriesIdDeleteExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var id = id_example;  // String |  (default to null)

            try {
                apiInstance.v1CategoriesIdDelete(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1CategoriesIdDelete: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $api_instance->v1CategoriesIdDelete($id);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1CategoriesIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $id = id_example; # String | 

eval {
    $api_instance->v1CategoriesIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1CategoriesIdDelete: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
id = id_example # String |  (default to null)

try:
    api_instance.v1_categories_id_delete(id)
except ApiException as e:
    print("Exception when calling DefaultApi->v1CategoriesIdDelete: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let id = id_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.v1CategoriesIdDelete(id, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            categoryOutput result = apiInstance.v1CategoriesIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CategoriesIdGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 

try {
    final result = await api_instance.v1CategoriesIdGet(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1CategoriesIdGet: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            categoryOutput result = apiInstance.v1CategoriesIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CategoriesIdGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *id = id_example; //  (default to null)

[apiInstance v1CategoriesIdGetWith:id
              completionHandler: ^(categoryOutput output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var id = id_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.v1CategoriesIdGet(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1CategoriesIdGetExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var id = id_example;  // String |  (default to null)

            try {
                categoryOutput result = apiInstance.v1CategoriesIdGet(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1CategoriesIdGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $result = $api_instance->v1CategoriesIdGet($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1CategoriesIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $id = id_example; # String | 

eval {
    my $result = $api_instance->v1CategoriesIdGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1CategoriesIdGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
id = id_example # String |  (default to null)

try:
    api_response = api_instance.v1_categories_id_get(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->v1CategoriesIdGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let id = id_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.v1CategoriesIdGet(id, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        CategoryInput categoryInput = ; // CategoryInput | 

        try {
            apiInstance.v1CategoriesIdPut(id, categoryInput);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CategoriesIdPut");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 
final CategoryInput categoryInput = new CategoryInput(); // CategoryInput | 

try {
    final result = await api_instance.v1CategoriesIdPut(id, categoryInput);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1CategoriesIdPut: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        CategoryInput categoryInput = ; // CategoryInput | 

        try {
            apiInstance.v1CategoriesIdPut(id, categoryInput);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CategoriesIdPut");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *id = id_example; //  (default to null)
CategoryInput *categoryInput = ; // 

[apiInstance v1CategoriesIdPutWith:id
    categoryInput:categoryInput
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var id = id_example; // {String} 
var categoryInput = ; // {CategoryInput} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1CategoriesIdPut(id, categoryInput, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1CategoriesIdPutExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var id = id_example;  // String |  (default to null)
            var categoryInput = new CategoryInput(); // CategoryInput | 

            try {
                apiInstance.v1CategoriesIdPut(id, categoryInput);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1CategoriesIdPut: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$id = id_example; // String | 
$categoryInput = ; // CategoryInput | 

try {
    $api_instance->v1CategoriesIdPut($id, $categoryInput);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1CategoriesIdPut: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $id = id_example; # String | 
my $categoryInput = WWW::OPenAPIClient::Object::CategoryInput->new(); # CategoryInput | 

eval {
    $api_instance->v1CategoriesIdPut(id => $id, categoryInput => $categoryInput);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1CategoriesIdPut: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
id = id_example # String |  (default to null)
categoryInput =  # CategoryInput | 

try:
    api_instance.v1_categories_id_put(id, categoryInput)
except ApiException as e:
    print("Exception when calling DefaultApi->v1CategoriesIdPut: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let id = id_example; // String
    let categoryInput = ; // CategoryInput

    let mut context = DefaultApi::Context::default();
    let result = client.v1CategoriesIdPut(id, categoryInput, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        CategoryInput categoryInput = ; // CategoryInput | 

        try {
            apiInstance.v1CategoriesPost(categoryInput);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CategoriesPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CategoryInput categoryInput = new CategoryInput(); // CategoryInput | 

try {
    final result = await api_instance.v1CategoriesPost(categoryInput);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1CategoriesPost: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        CategoryInput categoryInput = ; // CategoryInput | 

        try {
            apiInstance.v1CategoriesPost(categoryInput);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CategoriesPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
CategoryInput *categoryInput = ; // 

[apiInstance v1CategoriesPostWith:categoryInput
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var categoryInput = ; // {CategoryInput} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1CategoriesPost(categoryInput, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1CategoriesPostExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var categoryInput = new CategoryInput(); // CategoryInput | 

            try {
                apiInstance.v1CategoriesPost(categoryInput);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1CategoriesPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$categoryInput = ; // CategoryInput | 

try {
    $api_instance->v1CategoriesPost($categoryInput);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1CategoriesPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $categoryInput = WWW::OPenAPIClient::Object::CategoryInput->new(); # CategoryInput | 

eval {
    $api_instance->v1CategoriesPost(categoryInput => $categoryInput);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1CategoriesPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
categoryInput =  # CategoryInput | 

try:
    api_instance.v1_categories_post(categoryInput)
except ApiException as e:
    print("Exception when calling DefaultApi->v1CategoriesPost: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let categoryInput = ; // CategoryInput

    let mut context = DefaultApi::Context::default();
    let result = client.v1CategoriesPost(categoryInput, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String supplierId = supplierId_example; // String | 

        try {
            array[circuitOutputArray_inner] result = apiInstance.v1CircuitsGet(supplierId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CircuitsGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String supplierId = new String(); // String | 

try {
    final result = await api_instance.v1CircuitsGet(supplierId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1CircuitsGet: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String supplierId = supplierId_example; // String | 

        try {
            array[circuitOutputArray_inner] result = apiInstance.v1CircuitsGet(supplierId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CircuitsGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *supplierId = supplierId_example; //  (default to null)

[apiInstance v1CircuitsGetWith:supplierId
              completionHandler: ^(array[circuitOutputArray_inner] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var supplierId = supplierId_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.v1CircuitsGet(supplierId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1CircuitsGetExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var supplierId = supplierId_example;  // String |  (default to null)

            try {
                array[circuitOutputArray_inner] result = apiInstance.v1CircuitsGet(supplierId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1CircuitsGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$supplierId = supplierId_example; // String | 

try {
    $result = $api_instance->v1CircuitsGet($supplierId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1CircuitsGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $supplierId = supplierId_example; # String | 

eval {
    my $result = $api_instance->v1CircuitsGet(supplierId => $supplierId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1CircuitsGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
supplierId = supplierId_example # String |  (default to null)

try:
    api_response = api_instance.v1_circuits_get(supplierId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->v1CircuitsGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let supplierId = supplierId_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.v1CircuitsGet(supplierId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        array[circuitOutputArray_inner] circuitOutputArrayInner = ; // array[circuitOutputArray_inner] | 

        try {
            apiInstance.v1CircuitsPatch(circuitOutputArrayInner);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CircuitsPatch");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final array[circuitOutputArray_inner] circuitOutputArrayInner = new array[circuitOutputArray_inner](); // array[circuitOutputArray_inner] | 

try {
    final result = await api_instance.v1CircuitsPatch(circuitOutputArrayInner);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1CircuitsPatch: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        array[circuitOutputArray_inner] circuitOutputArrayInner = ; // array[circuitOutputArray_inner] | 

        try {
            apiInstance.v1CircuitsPatch(circuitOutputArrayInner);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CircuitsPatch");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
array[circuitOutputArray_inner] *circuitOutputArrayInner = ; // 

[apiInstance v1CircuitsPatchWith:circuitOutputArrayInner
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var circuitOutputArrayInner = ; // {array[circuitOutputArray_inner]} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1CircuitsPatch(circuitOutputArrayInner, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1CircuitsPatchExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var circuitOutputArrayInner = new array[circuitOutputArray_inner](); // array[circuitOutputArray_inner] | 

            try {
                apiInstance.v1CircuitsPatch(circuitOutputArrayInner);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1CircuitsPatch: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$circuitOutputArrayInner = ; // array[circuitOutputArray_inner] | 

try {
    $api_instance->v1CircuitsPatch($circuitOutputArrayInner);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1CircuitsPatch: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $circuitOutputArrayInner = [WWW::OPenAPIClient::Object::array[circuitOutputArray_inner]->new()]; # array[circuitOutputArray_inner] | 

eval {
    $api_instance->v1CircuitsPatch(circuitOutputArrayInner => $circuitOutputArrayInner);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1CircuitsPatch: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
circuitOutputArrayInner =  # array[circuitOutputArray_inner] | 

try:
    api_instance.v1_circuits_patch(circuitOutputArrayInner)
except ApiException as e:
    print("Exception when calling DefaultApi->v1CircuitsPatch: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let circuitOutputArrayInner = ; // array[circuitOutputArray_inner]

    let mut context = DefaultApi::Context::default();
    let result = client.v1CircuitsPatch(circuitOutputArrayInner, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            apiInstance.v1CustomersIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CustomersIdDelete");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 

try {
    final result = await api_instance.v1CustomersIdDelete(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1CustomersIdDelete: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            apiInstance.v1CustomersIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CustomersIdDelete");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *id = id_example; //  (default to null)

[apiInstance v1CustomersIdDeleteWith:id
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var id = id_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1CustomersIdDelete(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1CustomersIdDeleteExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var id = id_example;  // String |  (default to null)

            try {
                apiInstance.v1CustomersIdDelete(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1CustomersIdDelete: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $api_instance->v1CustomersIdDelete($id);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1CustomersIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $id = id_example; # String | 

eval {
    $api_instance->v1CustomersIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1CustomersIdDelete: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
id = id_example # String |  (default to null)

try:
    api_instance.v1_customers_id_delete(id)
except ApiException as e:
    print("Exception when calling DefaultApi->v1CustomersIdDelete: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let id = id_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.v1CustomersIdDelete(id, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            customerOutput result = apiInstance.v1CustomersIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CustomersIdGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 

try {
    final result = await api_instance.v1CustomersIdGet(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1CustomersIdGet: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            customerOutput result = apiInstance.v1CustomersIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CustomersIdGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *id = id_example; //  (default to null)

[apiInstance v1CustomersIdGetWith:id
              completionHandler: ^(customerOutput output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var id = id_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.v1CustomersIdGet(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1CustomersIdGetExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var id = id_example;  // String |  (default to null)

            try {
                customerOutput result = apiInstance.v1CustomersIdGet(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1CustomersIdGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $result = $api_instance->v1CustomersIdGet($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1CustomersIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $id = id_example; # String | 

eval {
    my $result = $api_instance->v1CustomersIdGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1CustomersIdGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
id = id_example # String |  (default to null)

try:
    api_response = api_instance.v1_customers_id_get(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->v1CustomersIdGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let id = id_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.v1CustomersIdGet(id, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            customerOutput result = apiInstance.v1CustomersIdIntentsGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CustomersIdIntentsGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 

try {
    final result = await api_instance.v1CustomersIdIntentsGet(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1CustomersIdIntentsGet: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            customerOutput result = apiInstance.v1CustomersIdIntentsGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CustomersIdIntentsGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *id = id_example; //  (default to null)

[apiInstance v1CustomersIdIntentsGetWith:id
              completionHandler: ^(customerOutput output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var id = id_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.v1CustomersIdIntentsGet(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1CustomersIdIntentsGetExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var id = id_example;  // String |  (default to null)

            try {
                customerOutput result = apiInstance.v1CustomersIdIntentsGet(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1CustomersIdIntentsGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $result = $api_instance->v1CustomersIdIntentsGet($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1CustomersIdIntentsGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $id = id_example; # String | 

eval {
    my $result = $api_instance->v1CustomersIdIntentsGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1CustomersIdIntentsGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
id = id_example # String |  (default to null)

try:
    api_response = api_instance.v1_customers_id_intents_get(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->v1CustomersIdIntentsGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let id = id_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.v1CustomersIdIntentsGet(id, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        CustomerInput customerInput = ; // CustomerInput | 

        try {
            apiInstance.v1CustomersIdPut(id, customerInput);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CustomersIdPut");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 
final CustomerInput customerInput = new CustomerInput(); // CustomerInput | 

try {
    final result = await api_instance.v1CustomersIdPut(id, customerInput);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1CustomersIdPut: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        CustomerInput customerInput = ; // CustomerInput | 

        try {
            apiInstance.v1CustomersIdPut(id, customerInput);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CustomersIdPut");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *id = id_example; //  (default to null)
CustomerInput *customerInput = ; // 

[apiInstance v1CustomersIdPutWith:id
    customerInput:customerInput
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var id = id_example; // {String} 
var customerInput = ; // {CustomerInput} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1CustomersIdPut(id, customerInput, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1CustomersIdPutExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var id = id_example;  // String |  (default to null)
            var customerInput = new CustomerInput(); // CustomerInput | 

            try {
                apiInstance.v1CustomersIdPut(id, customerInput);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1CustomersIdPut: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$id = id_example; // String | 
$customerInput = ; // CustomerInput | 

try {
    $api_instance->v1CustomersIdPut($id, $customerInput);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1CustomersIdPut: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $id = id_example; # String | 
my $customerInput = WWW::OPenAPIClient::Object::CustomerInput->new(); # CustomerInput | 

eval {
    $api_instance->v1CustomersIdPut(id => $id, customerInput => $customerInput);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1CustomersIdPut: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
id = id_example # String |  (default to null)
customerInput =  # CustomerInput | 

try:
    api_instance.v1_customers_id_put(id, customerInput)
except ApiException as e:
    print("Exception when calling DefaultApi->v1CustomersIdPut: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let id = id_example; // String
    let customerInput = ; // CustomerInput

    let mut context = DefaultApi::Context::default();
    let result = client.v1CustomersIdPut(id, customerInput, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            customerOutput result = apiInstance.v1CustomersIdQrGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CustomersIdQrGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 

try {
    final result = await api_instance.v1CustomersIdQrGet(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1CustomersIdQrGet: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            customerOutput result = apiInstance.v1CustomersIdQrGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CustomersIdQrGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *id = id_example; //  (default to null)

[apiInstance v1CustomersIdQrGetWith:id
              completionHandler: ^(customerOutput output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var id = id_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.v1CustomersIdQrGet(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1CustomersIdQrGetExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var id = id_example;  // String |  (default to null)

            try {
                customerOutput result = apiInstance.v1CustomersIdQrGet(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1CustomersIdQrGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $result = $api_instance->v1CustomersIdQrGet($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1CustomersIdQrGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $id = id_example; # String | 

eval {
    my $result = $api_instance->v1CustomersIdQrGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1CustomersIdQrGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
id = id_example # String |  (default to null)

try:
    api_response = api_instance.v1_customers_id_qr_get(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->v1CustomersIdQrGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let id = id_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.v1CustomersIdQrGet(id, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            array[vehicleOutputArray_inner] result = apiInstance.v1CustomersIdVehiclesGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CustomersIdVehiclesGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 

try {
    final result = await api_instance.v1CustomersIdVehiclesGet(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1CustomersIdVehiclesGet: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            array[vehicleOutputArray_inner] result = apiInstance.v1CustomersIdVehiclesGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CustomersIdVehiclesGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *id = id_example; //  (default to null)

[apiInstance v1CustomersIdVehiclesGetWith:id
              completionHandler: ^(array[vehicleOutputArray_inner] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var id = id_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.v1CustomersIdVehiclesGet(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1CustomersIdVehiclesGetExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var id = id_example;  // String |  (default to null)

            try {
                array[vehicleOutputArray_inner] result = apiInstance.v1CustomersIdVehiclesGet(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1CustomersIdVehiclesGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $result = $api_instance->v1CustomersIdVehiclesGet($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1CustomersIdVehiclesGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $id = id_example; # String | 

eval {
    my $result = $api_instance->v1CustomersIdVehiclesGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1CustomersIdVehiclesGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
id = id_example # String |  (default to null)

try:
    api_response = api_instance.v1_customers_id_vehicles_get(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->v1CustomersIdVehiclesGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let id = id_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.v1CustomersIdVehiclesGet(id, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            apiInstance.v1CustomersIntentsIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CustomersIntentsIdDelete");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 

try {
    final result = await api_instance.v1CustomersIntentsIdDelete(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1CustomersIntentsIdDelete: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            apiInstance.v1CustomersIntentsIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CustomersIntentsIdDelete");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *id = id_example; //  (default to null)

[apiInstance v1CustomersIntentsIdDeleteWith:id
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var id = id_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1CustomersIntentsIdDelete(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1CustomersIntentsIdDeleteExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var id = id_example;  // String |  (default to null)

            try {
                apiInstance.v1CustomersIntentsIdDelete(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1CustomersIntentsIdDelete: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $api_instance->v1CustomersIntentsIdDelete($id);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1CustomersIntentsIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $id = id_example; # String | 

eval {
    $api_instance->v1CustomersIntentsIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1CustomersIntentsIdDelete: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
id = id_example # String |  (default to null)

try:
    api_instance.v1_customers_intents_id_delete(id)
except ApiException as e:
    print("Exception when calling DefaultApi->v1CustomersIntentsIdDelete: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let id = id_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.v1CustomersIntentsIdDelete(id, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        CustomerOutput customerOutput = ; // CustomerOutput | 

        try {
            apiInstance.v1CustomersIntentsPut(customerOutput);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CustomersIntentsPut");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CustomerOutput customerOutput = new CustomerOutput(); // CustomerOutput | 

try {
    final result = await api_instance.v1CustomersIntentsPut(customerOutput);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1CustomersIntentsPut: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        CustomerOutput customerOutput = ; // CustomerOutput | 

        try {
            apiInstance.v1CustomersIntentsPut(customerOutput);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CustomersIntentsPut");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
CustomerOutput *customerOutput = ; // 

[apiInstance v1CustomersIntentsPutWith:customerOutput
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var customerOutput = ; // {CustomerOutput} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1CustomersIntentsPut(customerOutput, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1CustomersIntentsPutExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var customerOutput = new CustomerOutput(); // CustomerOutput | 

            try {
                apiInstance.v1CustomersIntentsPut(customerOutput);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1CustomersIntentsPut: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$customerOutput = ; // CustomerOutput | 

try {
    $api_instance->v1CustomersIntentsPut($customerOutput);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1CustomersIntentsPut: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $customerOutput = WWW::OPenAPIClient::Object::CustomerOutput->new(); # CustomerOutput | 

eval {
    $api_instance->v1CustomersIntentsPut(customerOutput => $customerOutput);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1CustomersIntentsPut: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
customerOutput =  # CustomerOutput | 

try:
    api_instance.v1_customers_intents_put(customerOutput)
except ApiException as e:
    print("Exception when calling DefaultApi->v1CustomersIntentsPut: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let customerOutput = ; // CustomerOutput

    let mut context = DefaultApi::Context::default();
    let result = client.v1CustomersIntentsPut(customerOutput, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        CustomerInput customerInput = ; // CustomerInput | 

        try {
            apiInstance.v1CustomersPost(customerInput);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CustomersPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CustomerInput customerInput = new CustomerInput(); // CustomerInput | 

try {
    final result = await api_instance.v1CustomersPost(customerInput);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1CustomersPost: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        CustomerInput customerInput = ; // CustomerInput | 

        try {
            apiInstance.v1CustomersPost(customerInput);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CustomersPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
CustomerInput *customerInput = ; // 

[apiInstance v1CustomersPostWith:customerInput
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var customerInput = ; // {CustomerInput} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1CustomersPost(customerInput, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1CustomersPostExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var customerInput = new CustomerInput(); // CustomerInput | 

            try {
                apiInstance.v1CustomersPost(customerInput);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1CustomersPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$customerInput = ; // CustomerInput | 

try {
    $api_instance->v1CustomersPost($customerInput);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1CustomersPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $customerInput = WWW::OPenAPIClient::Object::CustomerInput->new(); # CustomerInput | 

eval {
    $api_instance->v1CustomersPost(customerInput => $customerInput);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1CustomersPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
customerInput =  # CustomerInput | 

try:
    api_instance.v1_customers_post(customerInput)
except ApiException as e:
    print("Exception when calling DefaultApi->v1CustomersPost: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let customerInput = ; // CustomerInput

    let mut context = DefaultApi::Context::default();
    let result = client.v1CustomersPost(customerInput, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String limit = limit_example; // String | 
        String dbOnly = dbOnly_example; // String | 
        String vat = vat_example; // String | 
        String name = name_example; // String | 
        String offset = offset_example; // String | 
        String fiscalCode = fiscalCode_example; // String | 
        String code = code_example; // String | 
        String supplierId = supplierId_example; // String | 

        try {
            array[customerOutputArray_inner] result = apiInstance.v1CustomersSearchGet(limit, dbOnly, vat, name, offset, fiscalCode, code, supplierId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CustomersSearchGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String limit = new String(); // String | 
final String dbOnly = new String(); // String | 
final String vat = new String(); // String | 
final String name = new String(); // String | 
final String offset = new String(); // String | 
final String fiscalCode = new String(); // String | 
final String code = new String(); // String | 
final String supplierId = new String(); // String | 

try {
    final result = await api_instance.v1CustomersSearchGet(limit, dbOnly, vat, name, offset, fiscalCode, code, supplierId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1CustomersSearchGet: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String limit = limit_example; // String | 
        String dbOnly = dbOnly_example; // String | 
        String vat = vat_example; // String | 
        String name = name_example; // String | 
        String offset = offset_example; // String | 
        String fiscalCode = fiscalCode_example; // String | 
        String code = code_example; // String | 
        String supplierId = supplierId_example; // String | 

        try {
            array[customerOutputArray_inner] result = apiInstance.v1CustomersSearchGet(limit, dbOnly, vat, name, offset, fiscalCode, code, supplierId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1CustomersSearchGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *limit = limit_example; //  (default to null)
String *dbOnly = dbOnly_example; //  (optional) (default to null)
String *vat = vat_example; //  (optional) (default to null)
String *name = name_example; //  (optional) (default to null)
String *offset = offset_example; //  (optional) (default to null)
String *fiscalCode = fiscalCode_example; //  (optional) (default to null)
String *code = code_example; //  (optional) (default to null)
String *supplierId = supplierId_example; //  (optional) (default to null)

[apiInstance v1CustomersSearchGetWith:limit
    dbOnly:dbOnly
    vat:vat
    name:name
    offset:offset
    fiscalCode:fiscalCode
    code:code
    supplierId:supplierId
              completionHandler: ^(array[customerOutputArray_inner] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var limit = limit_example; // {String} 
var opts = {
  'dbOnly': dbOnly_example, // {String} 
  'vat': vat_example, // {String} 
  'name': name_example, // {String} 
  'offset': offset_example, // {String} 
  'fiscalCode': fiscalCode_example, // {String} 
  'code': code_example, // {String} 
  'supplierId': supplierId_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.v1CustomersSearchGet(limit, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1CustomersSearchGetExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var limit = limit_example;  // String |  (default to null)
            var dbOnly = dbOnly_example;  // String |  (optional)  (default to null)
            var vat = vat_example;  // String |  (optional)  (default to null)
            var name = name_example;  // String |  (optional)  (default to null)
            var offset = offset_example;  // String |  (optional)  (default to null)
            var fiscalCode = fiscalCode_example;  // String |  (optional)  (default to null)
            var code = code_example;  // String |  (optional)  (default to null)
            var supplierId = supplierId_example;  // String |  (optional)  (default to null)

            try {
                array[customerOutputArray_inner] result = apiInstance.v1CustomersSearchGet(limit, dbOnly, vat, name, offset, fiscalCode, code, supplierId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1CustomersSearchGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$limit = limit_example; // String | 
$dbOnly = dbOnly_example; // String | 
$vat = vat_example; // String | 
$name = name_example; // String | 
$offset = offset_example; // String | 
$fiscalCode = fiscalCode_example; // String | 
$code = code_example; // String | 
$supplierId = supplierId_example; // String | 

try {
    $result = $api_instance->v1CustomersSearchGet($limit, $dbOnly, $vat, $name, $offset, $fiscalCode, $code, $supplierId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1CustomersSearchGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $limit = limit_example; # String | 
my $dbOnly = dbOnly_example; # String | 
my $vat = vat_example; # String | 
my $name = name_example; # String | 
my $offset = offset_example; # String | 
my $fiscalCode = fiscalCode_example; # String | 
my $code = code_example; # String | 
my $supplierId = supplierId_example; # String | 

eval {
    my $result = $api_instance->v1CustomersSearchGet(limit => $limit, dbOnly => $dbOnly, vat => $vat, name => $name, offset => $offset, fiscalCode => $fiscalCode, code => $code, supplierId => $supplierId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1CustomersSearchGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
limit = limit_example # String |  (default to null)
dbOnly = dbOnly_example # String |  (optional) (default to null)
vat = vat_example # String |  (optional) (default to null)
name = name_example # String |  (optional) (default to null)
offset = offset_example # String |  (optional) (default to null)
fiscalCode = fiscalCode_example # String |  (optional) (default to null)
code = code_example # String |  (optional) (default to null)
supplierId = supplierId_example # String |  (optional) (default to null)

try:
    api_response = api_instance.v1_customers_search_get(limit, dbOnly=dbOnly, vat=vat, name=name, offset=offset, fiscalCode=fiscalCode, code=code, supplierId=supplierId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->v1CustomersSearchGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let limit = limit_example; // String
    let dbOnly = dbOnly_example; // String
    let vat = vat_example; // String
    let name = name_example; // String
    let offset = offset_example; // String
    let fiscalCode = fiscalCode_example; // String
    let code = code_example; // String
    let supplierId = supplierId_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.v1CustomersSearchGet(limit, dbOnly, vat, name, offset, fiscalCode, code, supplierId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            array[fuelcouponUnlockHistoryOutputArray_inner] result = apiInstance.v1FuelcouponsIdUnlockHistoryGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1FuelcouponsIdUnlockHistoryGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 

try {
    final result = await api_instance.v1FuelcouponsIdUnlockHistoryGet(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1FuelcouponsIdUnlockHistoryGet: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            array[fuelcouponUnlockHistoryOutputArray_inner] result = apiInstance.v1FuelcouponsIdUnlockHistoryGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1FuelcouponsIdUnlockHistoryGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *id = id_example; //  (default to null)

[apiInstance v1FuelcouponsIdUnlockHistoryGetWith:id
              completionHandler: ^(array[fuelcouponUnlockHistoryOutputArray_inner] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var id = id_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.v1FuelcouponsIdUnlockHistoryGet(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1FuelcouponsIdUnlockHistoryGetExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var id = id_example;  // String |  (default to null)

            try {
                array[fuelcouponUnlockHistoryOutputArray_inner] result = apiInstance.v1FuelcouponsIdUnlockHistoryGet(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1FuelcouponsIdUnlockHistoryGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $result = $api_instance->v1FuelcouponsIdUnlockHistoryGet($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1FuelcouponsIdUnlockHistoryGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $id = id_example; # String | 

eval {
    my $result = $api_instance->v1FuelcouponsIdUnlockHistoryGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1FuelcouponsIdUnlockHistoryGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
id = id_example # String |  (default to null)

try:
    api_response = api_instance.v1_fuelcoupons_id_unlock_history_get(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->v1FuelcouponsIdUnlockHistoryGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let id = id_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.v1FuelcouponsIdUnlockHistoryGet(id, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String isCode = isCode_example; // String | 
        String supplierCode = supplierCode_example; // String | 

        try {
            apiInstance.v1FuelstationsCheckGet(isCode, supplierCode);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1FuelstationsCheckGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String isCode = new String(); // String | 
final String supplierCode = new String(); // String | 

try {
    final result = await api_instance.v1FuelstationsCheckGet(isCode, supplierCode);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1FuelstationsCheckGet: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String isCode = isCode_example; // String | 
        String supplierCode = supplierCode_example; // String | 

        try {
            apiInstance.v1FuelstationsCheckGet(isCode, supplierCode);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1FuelstationsCheckGet");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *isCode = isCode_example; //  (optional) (default to null)
String *supplierCode = supplierCode_example; //  (optional) (default to null)

// Your GET endpoint
[apiInstance v1FuelstationsCheckGetWith:isCode
    supplierCode:supplierCode
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var opts = {
  'isCode': isCode_example, // {String} 
  'supplierCode': supplierCode_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1FuelstationsCheckGet(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1FuelstationsCheckGetExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var isCode = isCode_example;  // String |  (optional)  (default to null)
            var supplierCode = supplierCode_example;  // String |  (optional)  (default to null)

            try {
                // Your GET endpoint
                apiInstance.v1FuelstationsCheckGet(isCode, supplierCode);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1FuelstationsCheckGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$isCode = isCode_example; // String | 
$supplierCode = supplierCode_example; // String | 

try {
    $api_instance->v1FuelstationsCheckGet($isCode, $supplierCode);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1FuelstationsCheckGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $isCode = isCode_example; # String | 
my $supplierCode = supplierCode_example; # String | 

eval {
    $api_instance->v1FuelstationsCheckGet(isCode => $isCode, supplierCode => $supplierCode);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1FuelstationsCheckGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
isCode = isCode_example # String |  (optional) (default to null)
supplierCode = supplierCode_example # String |  (optional) (default to null)

try:
    # Your GET endpoint
    api_instance.v1_fuelstations_check_get(isCode=isCode, supplierCode=supplierCode)
except ApiException as e:
    print("Exception when calling DefaultApi->v1FuelstationsCheckGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let isCode = isCode_example; // String
    let supplierCode = supplierCode_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.v1FuelstationsCheckGet(isCode, supplierCode, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String sourceApp = sourceApp_example; // String | 
        String supplierId = supplierId_example; // String | 

        try {
            array[fuelStationsOutputArray_inner] result = apiInstance.v1FuelstationsGet(sourceApp, supplierId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1FuelstationsGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String sourceApp = new String(); // String | 
final String supplierId = new String(); // String | 

try {
    final result = await api_instance.v1FuelstationsGet(sourceApp, supplierId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1FuelstationsGet: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String sourceApp = sourceApp_example; // String | 
        String supplierId = supplierId_example; // String | 

        try {
            array[fuelStationsOutputArray_inner] result = apiInstance.v1FuelstationsGet(sourceApp, supplierId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1FuelstationsGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *sourceApp = sourceApp_example; //  (default to null)
String *supplierId = supplierId_example; //  (optional) (default to null)

[apiInstance v1FuelstationsGetWith:sourceApp
    supplierId:supplierId
              completionHandler: ^(array[fuelStationsOutputArray_inner] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var sourceApp = sourceApp_example; // {String} 
var opts = {
  'supplierId': supplierId_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.v1FuelstationsGet(sourceApp, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1FuelstationsGetExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var sourceApp = sourceApp_example;  // String |  (default to null)
            var supplierId = supplierId_example;  // String |  (optional)  (default to null)

            try {
                array[fuelStationsOutputArray_inner] result = apiInstance.v1FuelstationsGet(sourceApp, supplierId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1FuelstationsGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$sourceApp = sourceApp_example; // String | 
$supplierId = supplierId_example; // String | 

try {
    $result = $api_instance->v1FuelstationsGet($sourceApp, $supplierId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1FuelstationsGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $sourceApp = sourceApp_example; # String | 
my $supplierId = supplierId_example; # String | 

eval {
    my $result = $api_instance->v1FuelstationsGet(sourceApp => $sourceApp, supplierId => $supplierId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1FuelstationsGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
sourceApp = sourceApp_example # String |  (default to null)
supplierId = supplierId_example # String |  (optional) (default to null)

try:
    api_response = api_instance.v1_fuelstations_get(sourceApp, supplierId=supplierId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->v1FuelstationsGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let sourceApp = sourceApp_example; // String
    let supplierId = supplierId_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.v1FuelstationsGet(sourceApp, supplierId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        String isQr = isQr_example; // String | 

        try {
            fuelStationOutput result = apiInstance.v1FuelstationsIdGet(id, isQr);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1FuelstationsIdGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 
final String isQr = new String(); // String | 

try {
    final result = await api_instance.v1FuelstationsIdGet(id, isQr);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1FuelstationsIdGet: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        String isQr = isQr_example; // String | 

        try {
            fuelStationOutput result = apiInstance.v1FuelstationsIdGet(id, isQr);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1FuelstationsIdGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *id = id_example; //  (default to null)
String *isQr = isQr_example; //  (optional) (default to null)

[apiInstance v1FuelstationsIdGetWith:id
    isQr:isQr
              completionHandler: ^(fuelStationOutput output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var id = id_example; // {String} 
var opts = {
  'isQr': isQr_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.v1FuelstationsIdGet(id, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1FuelstationsIdGetExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var id = id_example;  // String |  (default to null)
            var isQr = isQr_example;  // String |  (optional)  (default to null)

            try {
                fuelStationOutput result = apiInstance.v1FuelstationsIdGet(id, isQr);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1FuelstationsIdGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$id = id_example; // String | 
$isQr = isQr_example; // String | 

try {
    $result = $api_instance->v1FuelstationsIdGet($id, $isQr);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1FuelstationsIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $id = id_example; # String | 
my $isQr = isQr_example; # String | 

eval {
    my $result = $api_instance->v1FuelstationsIdGet(id => $id, isQr => $isQr);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1FuelstationsIdGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
id = id_example # String |  (default to null)
isQr = isQr_example # String |  (optional) (default to null)

try:
    api_response = api_instance.v1_fuelstations_id_get(id, isQr=isQr)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->v1FuelstationsIdGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let id = id_example; // String
    let isQr = isQr_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.v1FuelstationsIdGet(id, isQr, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            invoiceHeaderOutput result = apiInstance.v1FuelstationsIdInvoiceheadersGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1FuelstationsIdInvoiceheadersGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 

try {
    final result = await api_instance.v1FuelstationsIdInvoiceheadersGet(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1FuelstationsIdInvoiceheadersGet: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            invoiceHeaderOutput result = apiInstance.v1FuelstationsIdInvoiceheadersGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1FuelstationsIdInvoiceheadersGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *id = id_example; //  (default to null)

[apiInstance v1FuelstationsIdInvoiceheadersGetWith:id
              completionHandler: ^(invoiceHeaderOutput output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var id = id_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.v1FuelstationsIdInvoiceheadersGet(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1FuelstationsIdInvoiceheadersGetExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var id = id_example;  // String |  (default to null)

            try {
                invoiceHeaderOutput result = apiInstance.v1FuelstationsIdInvoiceheadersGet(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1FuelstationsIdInvoiceheadersGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $result = $api_instance->v1FuelstationsIdInvoiceheadersGet($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1FuelstationsIdInvoiceheadersGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $id = id_example; # String | 

eval {
    my $result = $api_instance->v1FuelstationsIdInvoiceheadersGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1FuelstationsIdInvoiceheadersGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
id = id_example # String |  (default to null)

try:
    api_response = api_instance.v1_fuelstations_id_invoiceheaders_get(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->v1FuelstationsIdInvoiceheadersGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let id = id_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.v1FuelstationsIdInvoiceheadersGet(id, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        InvoiceHeaderInput invoiceHeaderInput = ; // InvoiceHeaderInput | 

        try {
            apiInstance.v1FuelstationsIdInvoiceheadersPost(id, invoiceHeaderInput);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1FuelstationsIdInvoiceheadersPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 
final InvoiceHeaderInput invoiceHeaderInput = new InvoiceHeaderInput(); // InvoiceHeaderInput | 

try {
    final result = await api_instance.v1FuelstationsIdInvoiceheadersPost(id, invoiceHeaderInput);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1FuelstationsIdInvoiceheadersPost: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        InvoiceHeaderInput invoiceHeaderInput = ; // InvoiceHeaderInput | 

        try {
            apiInstance.v1FuelstationsIdInvoiceheadersPost(id, invoiceHeaderInput);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1FuelstationsIdInvoiceheadersPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *id = id_example; //  (default to null)
InvoiceHeaderInput *invoiceHeaderInput = ; // 

[apiInstance v1FuelstationsIdInvoiceheadersPostWith:id
    invoiceHeaderInput:invoiceHeaderInput
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var id = id_example; // {String} 
var invoiceHeaderInput = ; // {InvoiceHeaderInput} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1FuelstationsIdInvoiceheadersPost(id, invoiceHeaderInput, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1FuelstationsIdInvoiceheadersPostExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var id = id_example;  // String |  (default to null)
            var invoiceHeaderInput = new InvoiceHeaderInput(); // InvoiceHeaderInput | 

            try {
                apiInstance.v1FuelstationsIdInvoiceheadersPost(id, invoiceHeaderInput);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1FuelstationsIdInvoiceheadersPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$id = id_example; // String | 
$invoiceHeaderInput = ; // InvoiceHeaderInput | 

try {
    $api_instance->v1FuelstationsIdInvoiceheadersPost($id, $invoiceHeaderInput);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1FuelstationsIdInvoiceheadersPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $id = id_example; # String | 
my $invoiceHeaderInput = WWW::OPenAPIClient::Object::InvoiceHeaderInput->new(); # InvoiceHeaderInput | 

eval {
    $api_instance->v1FuelstationsIdInvoiceheadersPost(id => $id, invoiceHeaderInput => $invoiceHeaderInput);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1FuelstationsIdInvoiceheadersPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
id = id_example # String |  (default to null)
invoiceHeaderInput =  # InvoiceHeaderInput | 

try:
    api_instance.v1_fuelstations_id_invoiceheaders_post(id, invoiceHeaderInput)
except ApiException as e:
    print("Exception when calling DefaultApi->v1FuelstationsIdInvoiceheadersPost: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let id = id_example; // String
    let invoiceHeaderInput = ; // InvoiceHeaderInput

    let mut context = DefaultApi::Context::default();
    let result = client.v1FuelstationsIdInvoiceheadersPost(id, invoiceHeaderInput, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        String articleId = articleId_example; // String | 
        String priceLevelId = priceLevelId_example; // String | 

        try {
            array[appliedPriceOutputArray_inner] result = apiInstance.v1FuelstationsIdPricesAppliedGet(id, articleId, priceLevelId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1FuelstationsIdPricesAppliedGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 
final String articleId = new String(); // String | 
final String priceLevelId = new String(); // String | 

try {
    final result = await api_instance.v1FuelstationsIdPricesAppliedGet(id, articleId, priceLevelId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1FuelstationsIdPricesAppliedGet: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        String articleId = articleId_example; // String | 
        String priceLevelId = priceLevelId_example; // String | 

        try {
            array[appliedPriceOutputArray_inner] result = apiInstance.v1FuelstationsIdPricesAppliedGet(id, articleId, priceLevelId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1FuelstationsIdPricesAppliedGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *id = id_example; //  (default to null)
String *articleId = articleId_example; //  (optional) (default to null)
String *priceLevelId = priceLevelId_example; //  (optional) (default to null)

[apiInstance v1FuelstationsIdPricesAppliedGetWith:id
    articleId:articleId
    priceLevelId:priceLevelId
              completionHandler: ^(array[appliedPriceOutputArray_inner] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var id = id_example; // {String} 
var opts = {
  'articleId': articleId_example, // {String} 
  'priceLevelId': priceLevelId_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.v1FuelstationsIdPricesAppliedGet(id, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1FuelstationsIdPricesAppliedGetExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var id = id_example;  // String |  (default to null)
            var articleId = articleId_example;  // String |  (optional)  (default to null)
            var priceLevelId = priceLevelId_example;  // String |  (optional)  (default to null)

            try {
                array[appliedPriceOutputArray_inner] result = apiInstance.v1FuelstationsIdPricesAppliedGet(id, articleId, priceLevelId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1FuelstationsIdPricesAppliedGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$id = id_example; // String | 
$articleId = articleId_example; // String | 
$priceLevelId = priceLevelId_example; // String | 

try {
    $result = $api_instance->v1FuelstationsIdPricesAppliedGet($id, $articleId, $priceLevelId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1FuelstationsIdPricesAppliedGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $id = id_example; # String | 
my $articleId = articleId_example; # String | 
my $priceLevelId = priceLevelId_example; # String | 

eval {
    my $result = $api_instance->v1FuelstationsIdPricesAppliedGet(id => $id, articleId => $articleId, priceLevelId => $priceLevelId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1FuelstationsIdPricesAppliedGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
id = id_example # String |  (default to null)
articleId = articleId_example # String |  (optional) (default to null)
priceLevelId = priceLevelId_example # String |  (optional) (default to null)

try:
    api_response = api_instance.v1_fuelstations_id_prices_applied_get(id, articleId=articleId, priceLevelId=priceLevelId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->v1FuelstationsIdPricesAppliedGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let id = id_example; // String
    let articleId = articleId_example; // String
    let priceLevelId = priceLevelId_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.v1FuelstationsIdPricesAppliedGet(id, articleId, priceLevelId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        FuelStationInput fuelStationInput = ; // FuelStationInput | 

        try {
            apiInstance.v1FuelstationsIdPut(id, fuelStationInput);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1FuelstationsIdPut");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 
final FuelStationInput fuelStationInput = new FuelStationInput(); // FuelStationInput | 

try {
    final result = await api_instance.v1FuelstationsIdPut(id, fuelStationInput);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1FuelstationsIdPut: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        FuelStationInput fuelStationInput = ; // FuelStationInput | 

        try {
            apiInstance.v1FuelstationsIdPut(id, fuelStationInput);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1FuelstationsIdPut");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *id = id_example; //  (default to null)
FuelStationInput *fuelStationInput = ; // 

[apiInstance v1FuelstationsIdPutWith:id
    fuelStationInput:fuelStationInput
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var id = id_example; // {String} 
var fuelStationInput = ; // {FuelStationInput} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1FuelstationsIdPut(id, fuelStationInput, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1FuelstationsIdPutExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var id = id_example;  // String |  (default to null)
            var fuelStationInput = new FuelStationInput(); // FuelStationInput | 

            try {
                apiInstance.v1FuelstationsIdPut(id, fuelStationInput);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1FuelstationsIdPut: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$id = id_example; // String | 
$fuelStationInput = ; // FuelStationInput | 

try {
    $api_instance->v1FuelstationsIdPut($id, $fuelStationInput);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1FuelstationsIdPut: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $id = id_example; # String | 
my $fuelStationInput = WWW::OPenAPIClient::Object::FuelStationInput->new(); # FuelStationInput | 

eval {
    $api_instance->v1FuelstationsIdPut(id => $id, fuelStationInput => $fuelStationInput);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1FuelstationsIdPut: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
id = id_example # String |  (default to null)
fuelStationInput =  # FuelStationInput | 

try:
    api_instance.v1_fuelstations_id_put(id, fuelStationInput)
except ApiException as e:
    print("Exception when calling DefaultApi->v1FuelstationsIdPut: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let id = id_example; // String
    let fuelStationInput = ; // FuelStationInput

    let mut context = DefaultApi::Context::default();
    let result = client.v1FuelstationsIdPut(id, fuelStationInput, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        FuelStationInput fuelStationInput = ; // FuelStationInput | 

        try {
            apiInstance.v1FuelstationsPost(fuelStationInput);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1FuelstationsPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final FuelStationInput fuelStationInput = new FuelStationInput(); // FuelStationInput | 

try {
    final result = await api_instance.v1FuelstationsPost(fuelStationInput);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1FuelstationsPost: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        FuelStationInput fuelStationInput = ; // FuelStationInput | 

        try {
            apiInstance.v1FuelstationsPost(fuelStationInput);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1FuelstationsPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
FuelStationInput *fuelStationInput = ; // 

[apiInstance v1FuelstationsPostWith:fuelStationInput
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var fuelStationInput = ; // {FuelStationInput} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1FuelstationsPost(fuelStationInput, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1FuelstationsPostExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var fuelStationInput = new FuelStationInput(); // FuelStationInput | 

            try {
                apiInstance.v1FuelstationsPost(fuelStationInput);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1FuelstationsPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$fuelStationInput = ; // FuelStationInput | 

try {
    $api_instance->v1FuelstationsPost($fuelStationInput);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1FuelstationsPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $fuelStationInput = WWW::OPenAPIClient::Object::FuelStationInput->new(); # FuelStationInput | 

eval {
    $api_instance->v1FuelstationsPost(fuelStationInput => $fuelStationInput);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1FuelstationsPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
fuelStationInput =  # FuelStationInput | 

try:
    api_instance.v1_fuelstations_post(fuelStationInput)
except ApiException as e:
    print("Exception when calling DefaultApi->v1FuelstationsPost: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let fuelStationInput = ; // FuelStationInput

    let mut context = DefaultApi::Context::default();
    let result = client.v1FuelstationsPost(fuelStationInput, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String longitude = longitude_example; // String | 
        String articles = articles_example; // String | 
        String latitude = latitude_example; // String | 
        String service = service_example; // String | 

        try {
            array[fuelStationOutputArray_inner] result = apiInstance.v1FuelstationsSearchGet(longitude, articles, latitude, service);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1FuelstationsSearchGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String longitude = new String(); // String | 
final String articles = new String(); // String | 
final String latitude = new String(); // String | 
final String service = new String(); // String | 

try {
    final result = await api_instance.v1FuelstationsSearchGet(longitude, articles, latitude, service);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1FuelstationsSearchGet: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String longitude = longitude_example; // String | 
        String articles = articles_example; // String | 
        String latitude = latitude_example; // String | 
        String service = service_example; // String | 

        try {
            array[fuelStationOutputArray_inner] result = apiInstance.v1FuelstationsSearchGet(longitude, articles, latitude, service);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1FuelstationsSearchGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *longitude = longitude_example; //  (optional) (default to null)
String *articles = articles_example; //  (optional) (default to null)
String *latitude = latitude_example; //  (optional) (default to null)
String *service = service_example; //  (optional) (default to null)

[apiInstance v1FuelstationsSearchGetWith:longitude
    articles:articles
    latitude:latitude
    service:service
              completionHandler: ^(array[fuelStationOutputArray_inner] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var opts = {
  'longitude': longitude_example, // {String} 
  'articles': articles_example, // {String} 
  'latitude': latitude_example, // {String} 
  'service': service_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.v1FuelstationsSearchGet(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1FuelstationsSearchGetExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var longitude = longitude_example;  // String |  (optional)  (default to null)
            var articles = articles_example;  // String |  (optional)  (default to null)
            var latitude = latitude_example;  // String |  (optional)  (default to null)
            var service = service_example;  // String |  (optional)  (default to null)

            try {
                array[fuelStationOutputArray_inner] result = apiInstance.v1FuelstationsSearchGet(longitude, articles, latitude, service);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1FuelstationsSearchGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$longitude = longitude_example; // String | 
$articles = articles_example; // String | 
$latitude = latitude_example; // String | 
$service = service_example; // String | 

try {
    $result = $api_instance->v1FuelstationsSearchGet($longitude, $articles, $latitude, $service);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1FuelstationsSearchGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $longitude = longitude_example; # String | 
my $articles = articles_example; # String | 
my $latitude = latitude_example; # String | 
my $service = service_example; # String | 

eval {
    my $result = $api_instance->v1FuelstationsSearchGet(longitude => $longitude, articles => $articles, latitude => $latitude, service => $service);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1FuelstationsSearchGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
longitude = longitude_example # String |  (optional) (default to null)
articles = articles_example # String |  (optional) (default to null)
latitude = latitude_example # String |  (optional) (default to null)
service = service_example # String |  (optional) (default to null)

try:
    api_response = api_instance.v1_fuelstations_search_get(longitude=longitude, articles=articles, latitude=latitude, service=service)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->v1FuelstationsSearchGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let longitude = longitude_example; // String
    let articles = articles_example; // String
    let latitude = latitude_example; // String
    let service = service_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.v1FuelstationsSearchGet(longitude, articles, latitude, service, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        Object body = Object; // Object | 

        try {
            apiInstance.v1FuelstationsSearchPricesAppliedMisePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1FuelstationsSearchPricesAppliedMisePost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Object body = new Object(); // Object | 

try {
    final result = await api_instance.v1FuelstationsSearchPricesAppliedMisePost(body);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1FuelstationsSearchPricesAppliedMisePost: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Object body = Object; // Object | 

        try {
            apiInstance.v1FuelstationsSearchPricesAppliedMisePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1FuelstationsSearchPricesAppliedMisePost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
Object *body = Object; // 

[apiInstance v1FuelstationsSearchPricesAppliedMisePostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var body = Object; // {Object} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1FuelstationsSearchPricesAppliedMisePost(body, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1FuelstationsSearchPricesAppliedMisePostExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var body = Object;  // Object | 

            try {
                apiInstance.v1FuelstationsSearchPricesAppliedMisePost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1FuelstationsSearchPricesAppliedMisePost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$body = Object; // Object | 

try {
    $api_instance->v1FuelstationsSearchPricesAppliedMisePost($body);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1FuelstationsSearchPricesAppliedMisePost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->v1FuelstationsSearchPricesAppliedMisePost(body => $body);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1FuelstationsSearchPricesAppliedMisePost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
body = Object # Object | 

try:
    api_instance.v1_fuelstations_search_prices_applied_mise_post(body)
except ApiException as e:
    print("Exception when calling DefaultApi->v1FuelstationsSearchPricesAppliedMisePost: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let body = Object; // Object

    let mut context = DefaultApi::Context::default();
    let result = client.v1FuelstationsSearchPricesAppliedMisePost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            invoiceHeaderOutput result = apiInstance.v1InvoiceheadersIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1InvoiceheadersIdGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 

try {
    final result = await api_instance.v1InvoiceheadersIdGet(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1InvoiceheadersIdGet: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 

        try {
            invoiceHeaderOutput result = apiInstance.v1InvoiceheadersIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1InvoiceheadersIdGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *id = id_example; //  (default to null)

[apiInstance v1InvoiceheadersIdGetWith:id
              completionHandler: ^(invoiceHeaderOutput output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var id = id_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.v1InvoiceheadersIdGet(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1InvoiceheadersIdGetExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var id = id_example;  // String |  (default to null)

            try {
                invoiceHeaderOutput result = apiInstance.v1InvoiceheadersIdGet(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1InvoiceheadersIdGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $result = $api_instance->v1InvoiceheadersIdGet($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1InvoiceheadersIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $id = id_example; # String | 

eval {
    my $result = $api_instance->v1InvoiceheadersIdGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1InvoiceheadersIdGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
id = id_example # String |  (default to null)

try:
    api_response = api_instance.v1_invoiceheaders_id_get(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->v1InvoiceheadersIdGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let id = id_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.v1InvoiceheadersIdGet(id, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        InvoiceHeaderInput invoiceHeaderInput = ; // InvoiceHeaderInput | 

        try {
            apiInstance.v1InvoiceheadersIdPut(id, invoiceHeaderInput);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1InvoiceheadersIdPut");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 
final InvoiceHeaderInput invoiceHeaderInput = new InvoiceHeaderInput(); // InvoiceHeaderInput | 

try {
    final result = await api_instance.v1InvoiceheadersIdPut(id, invoiceHeaderInput);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1InvoiceheadersIdPut: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        InvoiceHeaderInput invoiceHeaderInput = ; // InvoiceHeaderInput | 

        try {
            apiInstance.v1InvoiceheadersIdPut(id, invoiceHeaderInput);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1InvoiceheadersIdPut");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *id = id_example; //  (default to null)
InvoiceHeaderInput *invoiceHeaderInput = ; // 

[apiInstance v1InvoiceheadersIdPutWith:id
    invoiceHeaderInput:invoiceHeaderInput
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var id = id_example; // {String} 
var invoiceHeaderInput = ; // {InvoiceHeaderInput} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1InvoiceheadersIdPut(id, invoiceHeaderInput, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1InvoiceheadersIdPutExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var id = id_example;  // String |  (default to null)
            var invoiceHeaderInput = new InvoiceHeaderInput(); // InvoiceHeaderInput | 

            try {
                apiInstance.v1InvoiceheadersIdPut(id, invoiceHeaderInput);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1InvoiceheadersIdPut: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$id = id_example; // String | 
$invoiceHeaderInput = ; // InvoiceHeaderInput | 

try {
    $api_instance->v1InvoiceheadersIdPut($id, $invoiceHeaderInput);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1InvoiceheadersIdPut: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $id = id_example; # String | 
my $invoiceHeaderInput = WWW::OPenAPIClient::Object::InvoiceHeaderInput->new(); # InvoiceHeaderInput | 

eval {
    $api_instance->v1InvoiceheadersIdPut(id => $id, invoiceHeaderInput => $invoiceHeaderInput);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1InvoiceheadersIdPut: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
id = id_example # String |  (default to null)
invoiceHeaderInput =  # InvoiceHeaderInput | 

try:
    api_instance.v1_invoiceheaders_id_put(id, invoiceHeaderInput)
except ApiException as e:
    print("Exception when calling DefaultApi->v1InvoiceheadersIdPut: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let id = id_example; // String
    let invoiceHeaderInput = ; // InvoiceHeaderInput

    let mut context = DefaultApi::Context::default();
    let result = client.v1InvoiceheadersIdPut(id, invoiceHeaderInput, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: cognito
        OAuth cognito = (OAuth) defaultClient.getAuthentication("cognito");
        cognito.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        String detailid = detailid_example; // String | 

        try {
            array[invoiceBodyOutputArray_inner] result = apiInstance.v1InvoicesActiveIdDetailsDetailidGet(id, detailid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1InvoicesActiveIdDetailsDetailidGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 
final String detailid = new String(); // String | 

try {
    final result = await api_instance.v1InvoicesActiveIdDetailsDetailidGet(id, detailid);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->v1InvoicesActiveIdDetailsDetailidGet: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        String detailid = detailid_example; // String | 

        try {
            array[invoiceBodyOutputArray_inner] result = apiInstance.v1InvoicesActiveIdDetailsDetailidGet(id, detailid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#v1InvoicesActiveIdDetailsDetailidGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: cognito)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *id = id_example; //  (default to null)
String *detailid = detailid_example; //  (default to null)

[apiInstance v1InvoicesActiveIdDetailsDetailidGetWith:id
    detailid:detailid
              completionHandler: ^(array[invoiceBodyOutputArray_inner] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PublicApi = require('public_api');
var defaultClient = PublicApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: cognito
var cognito = defaultClient.authentications['cognito'];
cognito.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new PublicApi.DefaultApi()
var id = id_example; // {String} 
var detailid = detailid_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.v1InvoicesActiveIdDetailsDetailidGet(id, detailid, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class v1InvoicesActiveIdDetailsDetailidGetExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: cognito
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var id = id_example;  // String |  (default to null)
            var detailid = detailid_example;  // String |  (default to null)

            try {
                array[invoiceBodyOutputArray_inner] result = apiInstance.v1InvoicesActiveIdDetailsDetailidGet(id, detailid);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.v1InvoicesActiveIdDetailsDetailidGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: cognito
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$id = id_example; // String | 
$detailid = detailid_example; // String | 

try {
    $result = $api_instance->v1InvoicesActiveIdDetailsDetailidGet($id, $detailid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->v1InvoicesActiveIdDetailsDetailidGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure OAuth2 access token for authorization: cognito
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $id = id_example; # String | 
my $detailid = detailid_example; # String | 

eval {
    my $result = $api_instance->v1InvoicesActiveIdDetailsDetailidGet(id => $id, detailid => $detailid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->v1InvoicesActiveIdDetailsDetailidGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: cognito
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
id = id_example # String |  (default to null)
detailid = detailid_example # String |  (default to null)

try:
    api_response = api_instance.v1_invoices_active_id_details_detailid_get(id, detailid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->v1InvoicesActiveIdDetailsDetailidGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let id = id_example; // String
    let detailid = detailid_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.v1InvoicesActiveIdDetailsDetailidGet(id, detailid, &context).wait();

    println!("{:?}", result);
}